Merge lp:~vanvugt/mir/predictive-bypass-v3 into lp:mir

[Daniel van Vugt]

Introducing "predictive bypass"; this provides a constant ~10ms reduction
in latency when fully bypassed/overlayed. This benefit is in addition to
any lag reductions provided by other branches.

Additional unexpected benefits (free!):
  * In some cases even smoothness/frame rate is improved by this branch
    (LP: #1447896).
  * Software cursors/touchspots appear to "stick" to the client app better
    with this branch. Because the underlying client surface has the
    additional time it needs to update for the new cursor/touch position
    before the frame is posted.

This is version 3. Based on changes requested/suggested from version 2:
https://code.launchpad.net/~vanvugt/mir/predictive-bypass-2/+merge/261941

The sleep is still only allowed during bypass/overlaying so that time is never taken away from GL rendering. But you can force a specific sleep duration always-on using --composite-delay=MILLISECONDS
which is equivalent to what Weston does:
https://www.collabora.com/about-us/blog/2015/02/12/weston-repaint-scheduling/

Conversely, to turn off predictive bypass: --composite-delay=0

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2688
http://jenkins.qa.ubuntu.com/job/mir-ci/4224/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3040
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/560
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2988
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/380
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/380/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2988
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2988/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5801
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21537

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/4224/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

my complaints from v1 and v2 look addressed, lgtm!
Further improvements might be:
1) We can detect the device name on the android platform (via mga::DeviceQuirks), so we could have device-specific times.
2) This is passive (the MTC asks the DisplayGroup how long to wait), but I wouldn't mind the display hardware telling the MTC its ready to composite. (and mtc gets final say whether it does composite or not). This would also make the test for MTC less timing dependendent.

review: Approve

[Kevin DuBois (kdub)]

nit:
102 + (composite_delay_opt, po::value<int>()->default_value(-1),
103 + "Compositor frame delay in milliseconds (how long to wait for new "
104 + "frames from clients before compositing). Higher values result in "
105 + "lower latency. Default: Automatically determined.")

Instead of "higher values result in lower latency", perhaps "a properly tuned value can result in lower latency"? The current phrasing makes it tempting to set to a very high value.

[Chris Halse Rogers (raof)]

This seems good to me. Kevin's DisplayGroup driven composite idea seems good, too, but can be done later.

review: Approve

[Daniel van Vugt (vanvugt)]

I'm intentionally steering away from that right now. Because it's only an ideal time to post the next frame. Priority must still be given to the compositor which knows whether there needs to be a next frame at all. If nothing in the scene (or the "view") is changing then we need to stay asleep, and ignore what the recommended delay to the next frame is.

[Daniel van Vugt (vanvugt)]

review: Approve

[Chris Halse Rogers (raof)]

Hmm. It seems that we've been unclear.

The active display wouldn't *drive* the MTC. It would just replace the "you should probably wait at least $X ms" data member with a "you should probably wait at least until I signal you" signal. The MTC can still choose to wait longer (if there has been no scene change) or less time if it wanted to.

-----Original Message-----
From: "Daniel van Vugt" <email address hidden>
Sent: ‎30/‎06/‎2015 16:49
To: "Daniel van Vugt" <email address hidden>
Subject: Re: [Merge] lp:~vanvugt/mir/predictive-bypass-v3 into lp:mir

I'm intentionally steering away from that right now. Because it's only an ideal time to post the next frame. Priority must still be given to the compositor which knows whether there needs to be a next frame at all. If nothing in the scene (or the "view") is changing then we need to stay asleep, and ignore what the recommended delay to the next frame is.
--
https://code.launchpad.net/~vanvugt/mir/predictive-bypass-v3/+merge/263213
You are reviewing the proposed merge of lp:~vanvugt/mir/predictive-bypass-v3 into lp:mir.

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2690
http://jenkins.qa.ubuntu.com/job/mir-ci/4229/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3050
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-wily-amd64-build/570
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2998/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/385
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/385/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2998
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2998/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/5811/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/21563

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ci/4229/rebuild

review: Needs Fixing (continuous-integration)

[Chris Halse Rogers (raof)]

Did Jenkins just merge this after it failed CI?

--
Sent using Dekko from my Ubuntu device

=== modified file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2015-06-25 03:00:08 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2015-06-30 06:52:15 +0000
@@ -60,6 +60,11 @@
         
         last_sync = now;
     }
+
+    std::chrono::milliseconds recommended_sleep() const override
+    {
+        return std::chrono::milliseconds::zero();
+    }
     
     double const vsync_rate_in_hz;
 
 
=== modified file 'include/platform/mir/graphics/display.h'
--- include/platform/mir/graphics/display.h	2015-06-17 05:20:42 +0000
+++ include/platform/mir/graphics/display.h	2015-06-30 06:52:15 +0000
@@ -21,6 +21,7 @@
 
 #include <memory>
 #include <functional>
+#include <chrono>
 
 namespace mir
 {
@@ -63,6 +64,16 @@
      *  in the near future. On some platforms, this may wait a potentially long time for vsync. 
     **/
     virtual void post() = 0;
+
+    /**
+     * Returns a recommendation to the compositor as to how long it should
+     * wait before sampling the scene for the next frame. Sampling the
+     * scene too early results in up to one whole frame of extra lag if
+     * rendering is fast or skipped altogether (bypass/overlays). But sampling
+     * too late and we might miss the deadline. If unsure just return zero.
+     */
+    virtual std::chrono::milliseconds recommended_sleep() const = 0;
+
     virtual ~DisplaySyncGroup() = default;
 protected:
     DisplaySyncGroup() = default;
 
=== modified file 'include/test/mir/test/doubles/null_display_sync_group.h'
--- include/test/mir/test/doubles/null_display_sync_group.h	2015-06-25 03:00:08 +0000
+++ include/test/mir/test/doubles/null_display_sync_group.h	2015-06-30 06:52:15 +0000
@@ -55,6 +55,11 @@
         std::this_thread::yield();
     }
 
+    std::chrono::milliseconds recommended_sleep() const override
+    {
+        return std::chrono::milliseconds::zero();
+    }
+
 private:
     std::vector<geometry::Rectangle> const output_rects;
     std::vector<StubDisplayBuffer> display_buffers;
@@ -71,6 +76,12 @@
         /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
         std::this_thread::yield();
     }
+
+    std::chrono::milliseconds recommended_sleep() const override
+    {
+        return std::chrono::milliseconds::zero();
+    }
+
     NullDisplayBuffer db;
 };
 
 
=== modified file 'src/include/platform/mir/options/configuration.h'
--- src/include/platform/mir/options/configuration.h	2015-06-17 05:20:42 +0000
+++ src/include/platform/mir/options/configuration.h	2015-06-30 06:52:15 +0000
@@ -47,6 +47,7 @@
 extern char const* const fatal_abort_opt;
 extern char const* const debug_opt;
 extern char const* const nbuffers_opt;
+extern char const* const composite_delay_opt;
 extern char const* const enable_key_repeat_opt;
 
 extern char const* const name_opt;
 
=== modified file 'src/platform/options/default_configuration.cpp'
--- src/platform/options/default_configuration.cpp	2015-06-17 05:20:42 +0000
+++ src/platform/options/default_configuration.cpp	2015-06-30 06:52:15 +0000
@@ -49,6 +49,7 @@
 char const* const mo::fatal_abort_opt             = "on-fatal-error-abort";
 char const* const mo::debug_opt                   = "debug";
 char const* const mo::nbuffers_opt                = "nbuffers";
+char const* const mo::composite_delay_opt         = "composite-delay";
 char const* const mo::enable_key_repeat_opt       = "enable-key-repeat";
 
 char const* const mo::off_opt_value = "off";
@@ -173,6 +174,11 @@
             "threads in frontend thread pool.")
         (nbuffers_opt, po::value<int>()->default_value(3),
             "Number of buffers per surface.")
+        (composite_delay_opt, po::value<int>()->default_value(-1),
+            "Compositor frame delay in milliseconds (how long to wait for new "
+            "frames from clients before compositing). Higher values result in "
+            "lower latency but risk causing frame skipping. "
+            "Default: A negative value means decide automatically.")
         (name_opt, po::value<std::string>(),
             "When nested, the name Mir uses when registering with the host.")
         (offscreen_opt,
 
=== modified file 'src/platform/symbols.map'
--- src/platform/symbols.map	2015-06-17 05:20:42 +0000
+++ src/platform/symbols.map	2015-06-30 06:52:15 +0000
@@ -276,3 +276,13 @@
   };
  local: *;
 };
+
+# Why are server-only options here in libmirplatform?...
+MIRPLATFORM_7.1 {
+  global:
+    extern "C++" {
+      mir::options::composite_delay_opt*; 
+    };
+  local: *;
+} MIRPLATFORM_7;
+
 
=== modified file 'src/platforms/android/server/display_device.h'
--- src/platforms/android/server/display_device.h	2015-06-17 05:20:42 +0000
+++ src/platforms/android/server/display_device.h	2015-06-30 06:52:15 +0000
@@ -25,6 +25,7 @@
 #include "display_name.h"
 #include <EGL/egl.h>
 #include <list>
+#include <chrono>
 
 namespace mir
 {
@@ -66,6 +67,8 @@
     //notify the DisplayDevice that the screen content was cleared in a way other than the above fns
     virtual void content_cleared() = 0;
 
+    virtual std::chrono::milliseconds recommended_sleep() const = 0;
+
 protected:
     DisplayDevice() = default;
     DisplayDevice& operator=(DisplayDevice const&) = delete;
 
=== modified file 'src/platforms/android/server/display_group.cpp'
--- src/platforms/android/server/display_group.cpp	2015-05-19 17:17:39 +0000
+++ src/platforms/android/server/display_group.cpp	2015-06-30 06:52:15 +0000
@@ -81,3 +81,8 @@
         contents.emplace_back(db.second->contents());
     device->commit(contents); 
 }
+
+std::chrono::milliseconds mga::DisplayGroup::recommended_sleep() const
+{
+    return device->recommended_sleep();
+}
 
=== modified file 'src/platforms/android/server/display_group.h'
--- src/platforms/android/server/display_group.h	2015-05-19 17:16:12 +0000
+++ src/platforms/android/server/display_group.h	2015-06-30 06:52:15 +0000
@@ -44,6 +44,7 @@
 
     void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override;
     void post() override;
+    std::chrono::milliseconds recommended_sleep() const override;
 
     void add(DisplayName name, std::unique_ptr<ConfigurableDisplayBuffer> buffer);
     void remove(DisplayName name);
 
=== modified file 'src/platforms/android/server/fb_device.cpp'
--- src/platforms/android/server/fb_device.cpp	2015-06-17 05:20:42 +0000
+++ src/platforms/android/server/fb_device.cpp	2015-06-30 06:52:15 +0000
@@ -115,3 +115,8 @@
 void mga::FBDevice::content_cleared()
 {
 }
+
+std::chrono::milliseconds mga::FBDevice::recommended_sleep() const
+{
+    return std::chrono::milliseconds::zero();
+}
 
=== modified file 'src/platforms/android/server/fb_device.h'
--- src/platforms/android/server/fb_device.h	2015-06-17 05:20:42 +0000
+++ src/platforms/android/server/fb_device.h	2015-06-30 06:52:15 +0000
@@ -51,6 +51,7 @@
 
     bool compatible_renderlist(RenderableList const& renderlist) override;
     void commit(std::list<DisplayContents> const& contents) override;
+    std::chrono::milliseconds recommended_sleep() const override;
 
 private:
     std::shared_ptr<framebuffer_device_t> const fb_device;
 
=== modified file 'src/platforms/android/server/hwc_device.cpp'
--- src/platforms/android/server/hwc_device.cpp	2015-06-17 05:20:42 +0000
+++ src/platforms/android/server/hwc_device.cpp	2015-06-30 06:52:15 +0000
@@ -27,6 +27,8 @@
 #include "mir/raii.h"
 #include <limits>
 #include <algorithm>
+#include <chrono>
+#include <thread>
 
 namespace mg = mir::graphics;
 namespace mga=mir::graphics::android;
@@ -97,6 +99,8 @@
 
     hwc_wrapper->prepare(lists);
 
+    bool purely_overlays = true;
+
     for (auto& content : contents)
     {
         if (content.list.needs_swapbuffers())
@@ -111,6 +115,7 @@
                 content.compositor.render(std::move(rejected_renderables), content.list_offset, content.context);
             content.list.setup_fb(content.context.last_rendered_buffer());
             content.list.swap_occurred();
+            purely_overlays = false;
         }
     
         //setup overlays
@@ -136,6 +141,20 @@
 
         mir::Fd retire_fd(content.list.retirement_fence());
     }
+
+    /*
+     * Test results (how long can we sleep for without missing a frame?):
+     *   arale:   10ms  (TODO: Find out why arale is so slow)
+     *   mako:    15ms
+     *   krillin: 11ms  (to be fair, the display is 67Hz)
+     */
+    using namespace std;
+    recommend_sleep = purely_overlays ? 10ms : 0ms;
+}
+
+std::chrono::milliseconds mga::HwcDevice::recommended_sleep() const
+{
+    return recommend_sleep;
 }
 
 void mga::HwcDevice::content_cleared()
 
=== modified file 'src/platforms/android/server/hwc_device.h'
--- src/platforms/android/server/hwc_device.h	2015-04-28 07:54:10 +0000
+++ src/platforms/android/server/hwc_device.h	2015-06-30 06:52:15 +0000
@@ -46,6 +46,7 @@
     bool compatible_renderlist(RenderableList const& renderlist) override;
     void commit(std::list<DisplayContents> const& contents) override;
     void content_cleared() override;
+    std::chrono::milliseconds recommended_sleep() const override;
 
 private:
     bool buffer_is_onscreen(Buffer const&) const;
@@ -53,6 +54,7 @@
 
     std::shared_ptr<HwcWrapper> const hwc_wrapper;
     std::shared_ptr<SyncFileOps> const sync_ops;
+    std::chrono::milliseconds recommend_sleep{0};
 };
 
 }
 
=== modified file 'src/platforms/android/server/hwc_fb_device.cpp'
--- src/platforms/android/server/hwc_fb_device.cpp	2015-06-17 05:20:42 +0000
+++ src/platforms/android/server/hwc_fb_device.cpp	2015-06-30 06:52:15 +0000
@@ -113,3 +113,8 @@
 void mga::HwcFbDevice::content_cleared()
 {
 }
+
+std::chrono::milliseconds mga::HwcFbDevice::recommended_sleep() const
+{
+    return std::chrono::milliseconds::zero();
+}
 
=== modified file 'src/platforms/android/server/hwc_fb_device.h'
--- src/platforms/android/server/hwc_fb_device.h	2015-04-28 07:54:10 +0000
+++ src/platforms/android/server/hwc_fb_device.h	2015-06-30 06:52:15 +0000
@@ -43,6 +43,7 @@
 
     bool compatible_renderlist(RenderableList const& renderlist) override;
     void commit(std::list<DisplayContents> const& contents) override;
+    std::chrono::milliseconds recommended_sleep() const override;
 
 private:
     void content_cleared() override;
 
=== modified file 'src/platforms/mesa/server/kms/display_buffer.cpp'
--- src/platforms/mesa/server/kms/display_buffer.cpp	2015-06-17 05:20:42 +0000
+++ src/platforms/mesa/server/kms/display_buffer.cpp	2015-06-30 06:52:15 +0000
@@ -28,6 +28,8 @@
 #include <GLES2/gl2.h>
 
 #include <stdexcept>
+#include <chrono>
+#include <thread>
 
 namespace mgm = mir::graphics::mesa;
 namespace geom = mir::geometry;
@@ -282,6 +284,11 @@
         needs_set_crtc = false;
     }
 
+    using namespace std;  // For operator""ms()
+
+    // Predicted worst case render time for the next frame...
+    auto predicted_render_time = 50ms;
+
     if (bypass_buf)
     {
         /*
@@ -295,6 +302,10 @@
          */
         scheduled_bypass_frame = bypass_buf;
         wait_for_page_flip();
+
+        // It's very likely the next frame will be bypassed like this one so
+        // we only need time for kernel page flip scheduling...
+        predicted_render_time = 5ms;
     }
     else
     {
@@ -306,11 +317,33 @@
         scheduled_composite_frame = bufobj;
         if (outputs.size() == 1)
             wait_for_page_flip();
+
+        /*
+         * TODO: If you're optimistic about your GPU performance and/or
+         *       measure it carefully you may wish to set predicted_render_time
+         *       to a lower value here for lower latency.
+         *
+         *predicted_render_time = 9ms; // e.g. about the same as Weston
+         */
     }
 
     // Buffer lifetimes are managed exclusively by scheduled*/visible* now
     bypass_buf = nullptr;
     bypass_bufobj = nullptr;
+
+    recommend_sleep = 0ms;
+    if (outputs.size() == 1)
+    {
+        auto const& output = outputs.front();
+        auto const min_frame_interval = 1000ms / output->max_refresh_rate();
+        if (predicted_render_time < min_frame_interval)
+            recommend_sleep = min_frame_interval - predicted_render_time;
+    }
+}
+
+std::chrono::milliseconds mgm::DisplayBuffer::recommended_sleep() const
+{
+    return recommend_sleep;
 }
 
 mgm::BufferObject* mgm::DisplayBuffer::get_front_buffer_object()
 
=== modified file 'src/platforms/mesa/server/kms/display_buffer.h'
--- src/platforms/mesa/server/kms/display_buffer.h	2015-06-17 05:20:42 +0000
+++ src/platforms/mesa/server/kms/display_buffer.h	2015-06-30 06:52:15 +0000
@@ -65,6 +65,7 @@
     void for_each_display_buffer(
         std::function<void(graphics::DisplayBuffer&)> const& f) override;
     void post() override;
+    std::chrono::milliseconds recommended_sleep() const override;
 
     MirOrientation orientation() const override;
     void set_orientation(MirOrientation const rot, geometry::Rectangle const& a);
@@ -93,6 +94,7 @@
     uint32_t fb_width, fb_height;
     MirOrientation rotation;
     std::atomic<bool> needs_set_crtc;
+    std::chrono::milliseconds recommend_sleep{0};
     bool page_flips_pending;
 };
 
 
=== modified file 'src/platforms/mesa/server/kms/kms_output.h'
--- src/platforms/mesa/server/kms/kms_output.h	2015-06-17 05:20:42 +0000
+++ src/platforms/mesa/server/kms/kms_output.h	2015-06-30 06:52:15 +0000
@@ -43,6 +43,14 @@
     virtual void configure(geometry::Displacement fb_offset, size_t kms_mode_index) = 0;
     virtual geometry::Size size() const = 0;
 
+    /**
+     * Approximate maximum refresh rate of this output to within 1Hz.
+     * Typically the rate is fixed (e.g. 60Hz) but it may also be variable as
+     * in Nvidia G-Sync/AMD FreeSync/VESA Adaptive Sync. So this function
+     * returns the maximum rate to expect.
+     */
+    virtual int max_refresh_rate() const = 0;
+
     virtual bool set_crtc(uint32_t fb_id) = 0;
     virtual void clear_crtc() = 0;
     virtual bool schedule_page_flip(uint32_t fb_id) = 0;
 
=== modified file 'src/platforms/mesa/server/kms/real_kms_output.cpp'
--- src/platforms/mesa/server/kms/real_kms_output.cpp	2015-06-17 05:20:42 +0000
+++ src/platforms/mesa/server/kms/real_kms_output.cpp	2015-06-30 06:52:15 +0000
@@ -188,6 +188,14 @@
     return {mode.hdisplay, mode.vdisplay};
 }
 
+int mgm::RealKMSOutput::max_refresh_rate() const
+{
+    // TODO: In future when DRM exposes FreeSync/Adaptive Sync/G-Sync info
+    //       this value may be calculated differently.
+    drmModeModeInfo const& current_mode = connector->modes[mode_index];
+    return current_mode.vrefresh;
+}
+
 void mgm::RealKMSOutput::configure(geom::Displacement offset, size_t kms_mode_index)
 {
     fb_offset = offset;
 
=== modified file 'src/platforms/mesa/server/kms/real_kms_output.h'
--- src/platforms/mesa/server/kms/real_kms_output.h	2015-06-17 05:20:42 +0000
+++ src/platforms/mesa/server/kms/real_kms_output.h	2015-06-30 06:52:15 +0000
@@ -44,6 +44,7 @@
     void reset();
     void configure(geometry::Displacement fb_offset, size_t kms_mode_index);
     geometry::Size size() const;
+    int max_refresh_rate() const;
 
     bool set_crtc(uint32_t fb_id);
     void clear_crtc();
 
=== modified file 'src/server/compositor/default_configuration.cpp'
--- src/server/compositor/default_configuration.cpp	2015-06-17 05:20:42 +0000
+++ src/server/compositor/default_configuration.cpp	2015-06-30 06:52:15 +0000
@@ -84,12 +84,16 @@
     return compositor(
         [this]()
         {
+            std::chrono::milliseconds const composite_delay(
+                the_options()->get<int>(options::composite_delay_opt));
+
             return std::make_shared<mc::MultiThreadedCompositor>(
                 the_display(),
                 the_scene(),
                 the_display_buffer_compositor_factory(),
                 the_shell(),
                 the_compositor_report(),
+                composite_delay,
                 !the_options()->is_set(options::host_socket_opt));
         });
 }
 
=== modified file 'src/server/compositor/multi_threaded_compositor.cpp'
--- src/server/compositor/multi_threaded_compositor.cpp	2015-06-18 14:33:10 +0000
+++ src/server/compositor/multi_threaded_compositor.cpp	2015-06-30 06:52:15 +0000
@@ -101,12 +101,14 @@
         mg::DisplaySyncGroup& group,
         std::shared_ptr<mc::Scene> const& scene,
         std::shared_ptr<DisplayListener> const& display_listener,
+        std::chrono::milliseconds fixed_composite_delay,
         std::shared_ptr<CompositorReport> const& report) :
         compositor_factory{db_compositor_factory},
         group(group),
         scene(scene),
         running{true},
         frames_scheduled{0},
+        force_sleep{fixed_composite_delay},
         display_listener{display_listener},
         report{report},
         started_future{started.get_future()}
@@ -182,6 +184,17 @@
                 }
                 group.post();
 
+                /*
+                 * "Predictive bypass" optimization: If the last frame was
+                 * bypassed/overlayed or you simply have a fast GPU, it is
+                 * beneficial to sleep for most of the next frame. This reduces
+                 * the latency between snapshotting the scene and post()
+                 * completing by almost a whole frame.
+                 */
+                auto delay = force_sleep >= std::chrono::milliseconds::zero() ?
+                             force_sleep : group.recommended_sleep();
+                std::this_thread::sleep_for(delay);
+
                 lock.lock();
 
                 /*
@@ -231,6 +244,7 @@
     std::shared_ptr<mc::Scene> const scene;
     bool running;
     int frames_scheduled;
+    std::chrono::milliseconds force_sleep{-1};
     std::mutex run_mutex;
     std::condition_variable run_cv;
     std::shared_ptr<DisplayListener> const display_listener;
@@ -248,6 +262,7 @@
     std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
     std::shared_ptr<DisplayListener> const& display_listener,
     std::shared_ptr<CompositorReport> const& compositor_report,
+    std::chrono::milliseconds fixed_composite_delay,
     bool compose_on_start)
     : display{display},
       scene{scene},
@@ -255,6 +270,7 @@
       display_listener{display_listener},
       report{compositor_report},
       state{CompositorState::stopped},
+      fixed_composite_delay{fixed_composite_delay},
       compose_on_start{compose_on_start},
       thread_pool{1}
 {
@@ -348,7 +364,8 @@
     display->for_each_display_sync_group([this](mg::DisplaySyncGroup& group)
     {
         auto thread_functor = std::make_unique<mc::CompositingFunctor>(
-            display_buffer_compositor_factory, group, scene, display_listener, report);
+            display_buffer_compositor_factory, group, scene, display_listener,
+            fixed_composite_delay, report);
 
         futures.push_back(thread_pool.run(std::ref(*thread_functor), &group));
         thread_functors.push_back(std::move(thread_functor));
 
=== modified file 'src/server/compositor/multi_threaded_compositor.h'
--- src/server/compositor/multi_threaded_compositor.h	2015-06-17 05:20:42 +0000
+++ src/server/compositor/multi_threaded_compositor.h	2015-06-30 06:52:15 +0000
@@ -65,6 +65,7 @@
         std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
         std::shared_ptr<DisplayListener> const& display_listener,
         std::shared_ptr<CompositorReport> const& compositor_report,
+        std::chrono::milliseconds fixed_composite_delay,  // -1 = automatic
         bool compose_on_start);
     ~MultiThreadedCompositor();
 
@@ -86,6 +87,7 @@
 
     std::mutex state_guard;
     CompositorState state;
+    std::chrono::milliseconds fixed_composite_delay;
     bool compose_on_start;
 
     void schedule_compositing(int number_composites);
 
=== modified file 'src/server/graphics/nested/display.cpp'
--- src/server/graphics/nested/display.cpp	2015-06-17 05:20:42 +0000
+++ src/server/graphics/nested/display.cpp	2015-06-30 06:52:15 +0000
@@ -137,6 +137,14 @@
 {
 }
 
+std::chrono::milliseconds
+mgn::detail::DisplaySyncGroup::recommended_sleep() const
+{
+    // TODO: Might make sense in future with nested bypass. We could save
+    //       almost another frame of lag!
+    return std::chrono::milliseconds::zero();
+}
+
 mgn::Display::Display(
     std::shared_ptr<mg::Platform> const& platform,
     std::shared_ptr<HostConnection> const& connection,
 
=== modified file 'src/server/graphics/nested/display.h'
--- src/server/graphics/nested/display.h	2015-06-17 05:20:42 +0000
+++ src/server/graphics/nested/display.h	2015-06-30 06:52:15 +0000
@@ -97,6 +97,7 @@
     DisplaySyncGroup(std::shared_ptr<detail::DisplayBuffer> const& output);
     void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const&) override;
     void post() override;
+    std::chrono::milliseconds recommended_sleep() const override;
 private:
     std::shared_ptr<detail::DisplayBuffer> const output;
 };
 
=== modified file 'src/server/graphics/offscreen/display.cpp'
--- src/server/graphics/offscreen/display.cpp	2015-06-17 05:20:42 +0000
+++ src/server/graphics/offscreen/display.cpp	2015-06-30 06:52:15 +0000
@@ -87,6 +87,12 @@
 {
 }
 
+std::chrono::milliseconds
+mgo::detail::DisplaySyncGroup::recommended_sleep() const
+{
+    return std::chrono::milliseconds::zero();
+}
+
 mgo::Display::Display(
     EGLNativeDisplayType egl_native_display,
     std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
 
=== modified file 'src/server/graphics/offscreen/display.h'
--- src/server/graphics/offscreen/display.h	2015-06-17 05:20:42 +0000
+++ src/server/graphics/offscreen/display.h	2015-06-30 06:52:15 +0000
@@ -64,6 +64,7 @@
     DisplaySyncGroup(std::unique_ptr<DisplayBuffer> output);
     void for_each_display_buffer(std::function<void(DisplayBuffer&)> const&) override;
     void post() override;
+    std::chrono::milliseconds recommended_sleep() const override;
 private:
     std::unique_ptr<DisplayBuffer> const output;
 };
 
=== modified file 'tests/include/mir/test/doubles/mock_display_device.h'
--- tests/include/mir/test/doubles/mock_display_device.h	2015-04-28 07:54:10 +0000
+++ tests/include/mir/test/doubles/mock_display_device.h	2015-06-30 06:52:15 +0000
@@ -40,6 +40,7 @@
     MOCK_METHOD1(commit, void(std::list<graphics::android::DisplayContents> const&));
     MOCK_METHOD1(compatible_renderlist, bool(
         graphics::RenderableList const&));
+    MOCK_CONST_METHOD0(recommended_sleep, std::chrono::milliseconds());
 };
 }
 }
 
=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-06-25 03:00:08 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2015-06-30 06:52:15 +0000
@@ -153,6 +153,9 @@
         mt::fake_shared(renderer_factory),
         null_comp_report};
 };
+
+std::chrono::milliseconds const default_delay{-1};
+
 }
 
 TEST_F(SurfaceStackCompositor, composes_on_start_if_told_to_in_constructor)
@@ -162,7 +165,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, true);
+        null_comp_report, default_delay, true);
     mt_compositor.start();
 
     EXPECT_TRUE(stub_primary_db.has_posted_at_least(1, timeout));
@@ -176,7 +179,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
     mt_compositor.start();
 
     EXPECT_TRUE(stub_primary_db.has_posted_at_least(0, timeout));
@@ -190,7 +193,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
     mt_compositor.start();
 
     stack.add_surface(stub_surface, default_params.depth, default_params.input_mode);
@@ -212,7 +215,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
     mt_compositor.start();
 
     stack.add_surface(stub_surface, default_params.depth, default_params.input_mode);
@@ -235,7 +238,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
     mt_compositor.start();
 
     stack.add_surface(stub_surface, default_params.depth, default_params.input_mode);
@@ -256,7 +259,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
     mt_compositor.start();
 
     stack.add_surface(stub_surface, default_params.depth, default_params.input_mode);
@@ -281,7 +284,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
 
     mt_compositor.start();
     stub_surface->move_to(geom::Point{1,1});
@@ -300,7 +303,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
 
     mt_compositor.start();
     stack.remove_surface(stub_surface);
@@ -322,7 +325,7 @@
         mt::fake_shared(stack),
         mt::fake_shared(dbc_factory),
         mt::fake_shared(stub_display_listener),
-        null_comp_report, false);
+        null_comp_report, default_delay, false);
 
     mt_compositor.start();
     stub_surface->primary_buffer_stream()->swap_buffers(&stubbuf, [](mg::Buffer*){});
 
=== modified file 'tests/mir_test_doubles/mock_drm.cpp'
--- tests/mir_test_doubles/mock_drm.cpp	2015-06-25 03:00:08 +0000
+++ tests/mir_test_doubles/mock_drm.cpp	2015-06-30 06:52:15 +0000
@@ -216,6 +216,11 @@
     mode.clock = clock;
     mode.htotal = htotal;
     mode.vtotal = vtotal;
+
+    uint32_t total = htotal;
+    total *= vtotal;  // extend to 32 bits
+    mode.vrefresh = clock * 1000UL / total;
+
     if (preferred)
         mode.type |= DRM_MODE_TYPE_PREFERRED;
 
 
=== modified file 'tests/unit-tests/compositor/test_multi_threaded_compositor.cpp'
--- tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2015-06-30 06:52:15 +0000
@@ -83,6 +83,10 @@
             f(buffer);            
         }
         void post() override {}
+        std::chrono::milliseconds recommended_sleep() const override
+        {
+            return std::chrono::milliseconds::zero();
+        }
         testing::NiceMock<mtd::MockDisplayBuffer> buffer; 
     };
 
@@ -358,6 +362,7 @@
 auto const null_report = mr::null_compositor_report();
 unsigned int const composites_per_update{1};
 auto const null_display_listener = std::make_shared<StubDisplayListener>();
+std::chrono::milliseconds const default_delay{-1};
 
 }
 
@@ -370,7 +375,7 @@
     auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     compositor.start();
 
@@ -396,6 +401,7 @@
                                            db_compositor_factory,
                                            null_display_listener,
                                            mock_report,
+                                           default_delay,
                                            true};
 
     EXPECT_CALL(*mock_report, started())
@@ -446,7 +452,7 @@
     auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     // Verify we're actually starting at zero frames
     EXPECT_TRUE(db_compositor_factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
@@ -507,7 +513,7 @@
     auto scene = std::make_shared<StubScene>();
     auto factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
     mc::MultiThreadedCompositor compositor{display, scene, factory,
-                                           null_display_listener, null_report, true};
+                                           null_display_listener, null_report, default_delay, true};
 
     EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
 
@@ -570,6 +576,58 @@
     compositor.stop();
 }
 
+TEST(MultiThreadedCompositor, recommended_sleep_throttles_compositor_loop)
+{
+    using namespace testing;
+    using namespace std::chrono;
+
+    unsigned int const nbuffers = 3;
+    milliseconds const recommendation(10);
+
+    auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
+    auto scene = std::make_shared<StubScene>();
+    auto factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
+    mc::MultiThreadedCompositor compositor{display, scene, factory,
+                                           null_display_listener, null_report,
+                                           recommendation, false};
+
+    EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
+
+    compositor.start();
+
+    int const max_retries = 100;
+    int const nframes = 10;
+    auto start = system_clock::now();
+
+    for (int frame = 1; frame <= nframes; ++frame)
+    {
+        scene->emit_change_event();
+
+        int retry = 0;
+        while (retry < max_retries &&
+               !factory->check_record_count_for_each_buffer(nbuffers, frame))
+        {
+            std::this_thread::sleep_for(milliseconds(1));
+            ++retry;
+        }
+        ASSERT_LT(retry, max_retries);
+    }
+
+    /*
+     * Detecting the throttling from outside the compositor thread is actually
+     * trickier than you think. Because the display buffer counter won't be
+     * delayed by the sleep; only the subsequent frame will be delayed. So
+     * that's why we measure overall duration here...
+     */
+    auto duration = system_clock::now() - start;
+    // Minus 2 because the first won't be throttled, and the last not detected.
+    int minimum = recommendation.count() * (nframes - 2);
+    ASSERT_THAT(duration_cast<milliseconds>(duration).count(),
+                Ge(minimum));
+
+    compositor.stop();
+}
+
 TEST(MultiThreadedCompositor, when_no_initial_composite_is_needed_there_is_none)
 {
     using namespace testing;
@@ -579,7 +637,7 @@
     auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, false};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, false};
 
     // Verify we're actually starting at zero frames
     ASSERT_TRUE(db_compositor_factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
@@ -602,7 +660,7 @@
     auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, false};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, false};
 
     compositor.start();
 
@@ -637,7 +695,7 @@
     auto display = std::make_shared<mtd::StubDisplay>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<SurfaceUpdatingDisplayBufferCompositorFactory>(scene);
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     compositor.start();
 
@@ -656,7 +714,7 @@
     auto display = std::make_shared<StubDisplayWithMockBuffers>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<mtd::NullDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     display->for_each_mock_buffer([](mtd::MockDisplayBuffer& mock_buf)
     {
@@ -692,7 +750,7 @@
         .Times(AtLeast(0))
         .WillRepeatedly(Return(mc::SceneElementSequence{}));
 
-    mc::MultiThreadedCompositor compositor{display, mock_scene, db_compositor_factory, null_display_listener, mock_report, true};
+    mc::MultiThreadedCompositor compositor{display, mock_scene, db_compositor_factory, null_display_listener, mock_report, default_delay, true};
 
     compositor.start();
     compositor.start();
@@ -707,7 +765,7 @@
     auto display = std::make_shared<StubDisplayWithMockBuffers>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     scene->throw_on_add_observer(true);
 
@@ -757,7 +815,7 @@
     auto display = std::make_shared<StubDisplayWithMockBuffers>(nbuffers);
     auto scene = std::make_shared<StubScene>();
     auto db_compositor_factory = std::make_shared<ThreadNameDisplayBufferCompositorFactory>();
-    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, true};
+    mc::MultiThreadedCompositor compositor{display, scene, db_compositor_factory, null_display_listener, null_report, default_delay, true};
 
     compositor.start();
 
@@ -786,7 +844,7 @@
     EXPECT_CALL(*mock_scene, register_compositor(_))
         .Times(nbuffers);
     mc::MultiThreadedCompositor compositor{
-        display, mock_scene, db_compositor_factory, null_display_listener, mock_report, true};
+        display, mock_scene, db_compositor_factory, null_display_listener, mock_report, default_delay, true};
 
     compositor.start();
 
@@ -809,7 +867,7 @@
     auto mock_report = std::make_shared<testing::NiceMock<mtd::MockCompositorReport>>();
 
     mc::MultiThreadedCompositor compositor{
-        display, stub_scene, db_compositor_factory, mock_display_listener, mock_report, true};
+        display, stub_scene, db_compositor_factory, mock_display_listener, mock_report, default_delay, true};
 
     EXPECT_CALL(*mock_display_listener, add_display(_)).Times(nbuffers);
 
@@ -840,7 +898,7 @@
         [&] { signal(SIGTERM, old_sigterm_handler); });
 
     mc::MultiThreadedCompositor compositor{
-        display, stub_scene, db_compositor_factory, mock_display_listener, mock_report, true};
+        display, stub_scene, db_compositor_factory, mock_display_listener, mock_report, default_delay, true};
 
     EXPECT_CALL(*mock_display_listener, add_display(_))
         .WillRepeatedly(Throw(std::runtime_error("Failed to add display")));
 
=== modified file 'tests/unit-tests/graphics/android/test_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_fb_device.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/graphics/android/test_fb_device.cpp	2015-06-30 06:52:15 +0000
@@ -100,6 +100,9 @@
     }, std::runtime_error);
 
     fbdev.commit({content});
+
+    // Predictive bypass not enabled in FBDevice
+    EXPECT_EQ(0, fbdev.recommended_sleep().count());
 }
 
 //not all fb devices provide a swap interval hook. make sure we don't explode if thats the case
 
=== modified file 'tests/unit-tests/graphics/android/test_hwc_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_device.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/graphics/android/test_hwc_device.cpp	2015-06-30 06:52:15 +0000
@@ -439,6 +439,49 @@
     EXPECT_THAT(stub_buffer1.use_count(), Eq(use_count_before));
 }
 
+TEST_F(HwcDevice, overlays_are_throttled_per_predictive_bypass)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_device, prepare(_))
+        .WillRepeatedly(Invoke(set_all_layers_to_overlay));
+
+    mga::HwcDevice device(mock_device);
+
+    mga::LayerList list(layer_adapter, {stub_renderable1}, {0,0});
+    mga::DisplayContents content{primary, list, offset, stub_context,
+                                 stub_compositor};
+
+    for (int frame = 0; frame < 5; ++frame)
+    {
+        device.commit({content});
+        ASSERT_THAT(device.recommended_sleep().count(), Ge(8));
+    }
+}
+
+TEST_F(HwcDevice, compositing_disables_predictive_bypass)
+{
+    using namespace testing;
+
+    NiceMock<mtd::MockSwappingGLContext> mock_context;
+    ON_CALL(mock_context, last_rendered_buffer())
+        .WillByDefault(Return(stub_fb_buffer));
+    EXPECT_CALL(mock_context, swap_buffers())
+        .Times(AtLeast(5));
+
+    mga::LayerList list(layer_adapter, {}, geom::Displacement{});
+    mtd::MockRenderableListCompositor mock_compositor;
+    mga::DisplayContents content{primary, list, offset, mock_context,
+                                 mock_compositor};
+
+    mga::HwcDevice device(mock_device);
+    device.commit({content});
+    for (int frame = 0; frame < 5; ++frame)
+    {
+        device.commit({content});
+        ASSERT_EQ(0, device.recommended_sleep().count());
+    }
+}
+
 TEST_F(HwcDevice, does_not_set_acquirefences_when_it_has_set_them_previously_without_update)
 {
     using namespace testing;
 
=== modified file 'tests/unit-tests/graphics/android/test_hwc_fb_device.cpp'
--- tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/graphics/android/test_hwc_fb_device.cpp	2015-06-30 06:52:15 +0000
@@ -174,4 +174,7 @@
 
     mga::DisplayContents content{primary, list, geom::Displacement{}, mock_context, stub_compositor};
     device.commit({content});
+
+    // Predictive bypass not enabled in HwcFbDevice
+    EXPECT_EQ(0, device.recommended_sleep().count());
 }
 
=== modified file 'tests/unit-tests/graphics/mesa/kms/mock_kms_output.h'
--- tests/unit-tests/graphics/mesa/kms/mock_kms_output.h	2015-06-17 05:20:42 +0000
+++ tests/unit-tests/graphics/mesa/kms/mock_kms_output.h	2015-06-30 06:52:15 +0000
@@ -32,6 +32,7 @@
     MOCK_METHOD0(reset, void());
     MOCK_METHOD2(configure, void(geometry::Displacement, size_t));
     MOCK_CONST_METHOD0(size, geometry::Size());
+    MOCK_CONST_METHOD0(max_refresh_rate, int());
 
     MOCK_METHOD1(set_crtc, bool(uint32_t));
     MOCK_METHOD0(clear_crtc, void());
 
=== modified file 'tests/unit-tests/graphics/mesa/kms/test_display_buffer.cpp'
--- tests/unit-tests/graphics/mesa/kms/test_display_buffer.cpp	2015-06-25 03:00:08 +0000
+++ tests/unit-tests/graphics/mesa/kms/test_display_buffer.cpp	2015-06-30 06:52:15 +0000
@@ -46,6 +46,8 @@
 class MesaDisplayBufferTest : public Test
 {
 public:
+    int const mock_refresh_rate = 60;
+
     MesaDisplayBufferTest()
         : mock_bypassable_buffer{std::make_shared<NiceMock<MockBuffer>>()}
         , fake_bypassable_renderable{
@@ -78,6 +80,8 @@
             .WillByDefault(Return(true));
         ON_CALL(*mock_kms_output, schedule_page_flip(_))
             .WillByDefault(Return(true));
+        ON_CALL(*mock_kms_output, max_refresh_rate())
+            .WillByDefault(Return(mock_refresh_rate));
 
         ON_CALL(*mock_bypassable_buffer, size())
             .WillByDefault(Return(display_area.size));
@@ -154,6 +158,56 @@
     EXPECT_EQ(original_count, mock_bypassable_buffer.use_count());
 }
 
+TEST_F(MesaDisplayBufferTest, predictive_bypass_is_throttled)
+{
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        null_display_report(),
+        {mock_kms_output},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+
+    for (int frame = 0; frame < 5; ++frame)
+    {
+        ASSERT_TRUE(db.post_renderables_if_optimizable(bypassable_list));
+        db.post();
+
+        // Cast to a simple int type so that test failures are readable
+        int milliseconds_per_frame = 1000 / mock_refresh_rate;
+        ASSERT_THAT(db.recommended_sleep().count(),
+                    Ge(milliseconds_per_frame/2));
+    }
+}
+
+TEST_F(MesaDisplayBufferTest, frames_requiring_gl_are_not_throttled)
+{
+    graphics::RenderableList non_bypassable_list{
+        std::make_shared<FakeRenderable>(geometry::Rectangle{{12, 34}, {1, 1}})
+    };
+
+    graphics::mesa::DisplayBuffer db(
+        create_platform(),
+        null_display_report(),
+        {mock_kms_output},
+        nullptr,
+        display_area,
+        mir_orientation_normal,
+        gl_config,
+        mock_egl.fake_egl_context);
+
+    for (int frame = 0; frame < 5; ++frame)
+    {
+        ASSERT_FALSE(db.post_renderables_if_optimizable(non_bypassable_list));
+        db.post();
+
+        // Cast to a simple int type so that test failures are readable
+        ASSERT_EQ(0, db.recommended_sleep().count());
+    }
+}
+
 TEST_F(MesaDisplayBufferTest, bypass_buffer_only_referenced_once_by_db)
 {
     graphics::mesa::DisplayBuffer db(
 
=== modified file 'tests/unit-tests/graphics/nested/test_nested_display.cpp'
--- tests/unit-tests/graphics/nested/test_nested_display.cpp	2015-06-25 13:43:43 +0000
+++ tests/unit-tests/graphics/nested/test_nested_display.cpp	2015-06-30 06:52:15 +0000
@@ -167,6 +167,23 @@
     EXPECT_FALSE(weak_platform.expired());
 }
 
+TEST_F(NestedDisplay, never_enables_predictive_bypass)
+{   // This test can be removed after it's implemented (after nested bypass)
+    auto const nested_display = create_nested_display(
+        null_platform,
+        mt::fake_shared(stub_gl_config));
+
+    int groups = 0;
+    nested_display->for_each_display_sync_group(
+        [&groups](mg::DisplaySyncGroup& g)
+        {
+            EXPECT_EQ(0, g.recommended_sleep().count());
+            ++groups;
+        }
+    );
+
+    ASSERT_NE(0, groups);
+}
 
 TEST_F(NestedDisplay, makes_context_current_on_creation_and_releases_on_destruction)
 {
 
=== modified file 'tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp'
--- tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2015-06-25 13:43:43 +0000
+++ tests/unit-tests/graphics/offscreen/test_offscreen_display.cpp	2015-06-30 06:52:15 +0000
@@ -78,6 +78,22 @@
     EXPECT_TRUE(count);
 }
 
+TEST_F(OffscreenDisplayTest, never_enables_predictive_bypass)
+{
+    mgo::Display display{
+        native_display,
+        std::make_shared<mg::CloneDisplayConfigurationPolicy>(),
+        mr::null_display_report()};
+
+    int groups = 0;
+    display.for_each_display_sync_group([&](mg::DisplaySyncGroup& group){
+        ++groups;
+        EXPECT_EQ(0, group.recommended_sleep().count());
+    });
+
+    EXPECT_TRUE(groups);
+}
+
 TEST_F(OffscreenDisplayTest, makes_fbo_current_rendering_target)
 {
     using namespace ::testing;