Merge lp:~afrantzis/mir/client-surface-buffering-mode into lp:mir

[Alexandros Frantzis]

client,server: Allow clients to specify the buffering mode for their surfaces

client,server: Allow clients to specify the buffering mode for their surfaces

This MP only allows setting the buffering mode at surface creation time. In the future it may be useful to also allow changing the buffering mode after creation time.

[Alan Griffiths (alan-griffiths)]

89+bool mir_surface_spec_set_buffering_mode(MirSurfaceSpec* spec, MirBufferingMode mode)
90+{
91+ spec->buffering_mode = mode;
92+ return true;
93+}

Possibly worth validating the buffering mode at this point and returning false if it is nonsense?

[Alan Griffiths (alan-griffiths)]

std::chrono::milliseconds{0}

You can use literals now

[Alan Griffiths (alan-griffiths)]

OK

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2490
http://jenkins.qa.ubuntu.com/job/mir-ci/3540/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2079
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2078
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2029
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1537/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2029
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2029/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4962
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19695

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

review: Needs Fixing (continuous-integration)

[Alexandros Frantzis (afrantzis)]

7: [ FAILED ] ServerShutdown.normal_exit_removes_endpoint
7: [ FAILED ] ClientFocusNotification.a_surface_is_notified_of_receiving_focus
7: [ FAILED ] ClientFocusNotification.two_surfaces_are_notified_of_gaining_and_losing_focus
7: [ FAILED ] ClientCredsTestFixture.session_authorizer_receives_pid_of_connecting_clients
7: [ FAILED ] ClientCredsTestFixture.authorizer_may_prevent_connection_of_clients
7: [ FAILED ] ServerDisconnect.is_detected_by_client
7: [ FAILED ] ServerDisconnect.doesnt_stop_client_calling_API_functions
7: [ FAILED ] ServerDisconnect.causes_client_to_terminate_by_default
7: [ FAILED ] ServerStartup.creates_endpoint_on_filesystem
7: [ FAILED ] ServerStartup.after_server_sigkilled_can_start_new_instance
7: [ FAILED ] UnresponsiveClient.does_not_hang_server
7: [ FAILED ] CustomInputDispatcher.receives_input
7: [ FAILED ] CustomInputDispatcher.gets_started_and_stopped
7: [ FAILED ] CustomInputDispatcher.receives_focus_changes
7: [ FAILED ] FocusSelection.when_surface_created_shell_is_notified_of_session
7: [ FAILED ] FocusSelection.when_surface_created_input_focus_is_set

11: [ FAILED ] MultiplexingDispatchableTest.removal_is_threadsafe

Ehh?

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2490
http://jenkins.qa.ubuntu.com/job/mir-ci/3541/
Executed test runs:
    None: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2079/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2030/console
    None: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1538/console
    None: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2030/console

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

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

(0) In general I don't think this is a good idea. When I finish dynamic switching:
   https://code.launchpad.net/~vanvugt/mir/ddouble
only clients using the default auto setting will benefit. But we want all clients to benefit. So I suggest disapprove based on that.

(1) This enum doesn't need to exist. An int is clearer:
28 +typedef enum MirBufferingMode
29 +{
30 + mir_buffering_mode_default = 0,
31 + mir_buffering_mode_double = 2,
32 + mir_buffering_mode_triple = 3
33 +} MirBufferingMode;

review: Disapprove

[Daniel van Vugt (vanvugt)]

(0) Come to think of it, there still is a use case for this. In future if we support single buffering properly then we need this interface.

(1) Still needs to be an int.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2490
http://jenkins.qa.ubuntu.com/job/mir-ci/3543/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2082
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2081
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2032
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1540/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2032
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2032/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4964
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19702

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

review: Needs Fixing (continuous-integration)

[Kevin DuBois (kdub)]

It might be more flexible to just let the clients acquire more than one buffer at once, and then the clients just submit the buffer that they last-generated to the server for it to use.

Advantages:
* Gets us a bit closer to server-or-client-allocated buffers (as opposed to our server allocated buffers nowadays)
* This diffuses the density of the logic in BufferQueue a bit, as the client shares in the responsibility of how the flip chain works.
* The server doesn't even have to know if the client is running in swapinterval 0 or not, it would just have a last-submitted buffer.
* Nested-passthrough can use the normal BufferQueue, instead of dancing around the limitation that it can only get one buffer at a time.
* nested becomes an normal platform, as it has a way to allocate a buffer.
* we don't have to hash out what "double" and "triple" means exactly in the client api.

review: Needs Information

[lp:~afrantzis/mir/client-surface-buffering-mode]

2491. By Alexandros Frantzis on 2015-04-17

client: Make mir_surface_spec_set_buffering_mode symbol public

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2491
http://jenkins.qa.ubuntu.com/job/mir-ci/3562/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/2106
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2105
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/2056
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1559
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/1559/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2056
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/2056/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/4988
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/19756

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

review: Approve (continuous-integration)

[Chris Halse Rogers (raof)]

*Needs discussion*

It *would* be more flexible for the client to be able to borrow multiple buffers. The simplifications Kevin mentions look pretty enticing.

It'd also make Daniel happy; we can make es2gears produce higher numbers in swapinterval 0 mode :).

This seems like it'd need a bit of design, though; particularly - what happens on resize or other invalidation, does the client need to submit buffers in the same order as received from the server?

Also worth wondering how we can use this to make Vulkan WSI easier.

review: Needs Information

[Alberto Aguirre (albaguirre)]

> (0) In general I don't think this is a good idea. When I finish dynamic
> switching:
> https://code.launchpad.net/~vanvugt/mir/ddouble
> only clients using the default auto setting will benefit. But we want all
> clients to benefit. So I suggest disapprove based on that.

Any predictive algorithm needs the ability to be disabled. Especially by the client, as that the entity that has more knowledge about it's own rendering (And the tradeoffs it wants to make) that what you can guess at the server

[Robert Carr (robertcarr)]

Kevins approach is compelling.

This is a good gain for now though.

review: Approve

[Daniel van Vugt (vanvugt)]

"Kevin's approach" sounds like what was described in bug 1253868. Maybe we need to reopen that...

[Alexandros Frantzis (afrantzis)]

It seems that we need to make some decisions at a higher level first (i.e. do allow clients to hold multiple buffers?) before deciding whether what's proposed in this MP is needed. The sprint seems a good time to discuss further.

[Chris Halse Rogers (raof)]

Yeah, I was expecting that we'd discuss this at the sprint.

Unmerged revisions

2491. By Alexandros Frantzis on 2015-04-17

client: Make mir_surface_spec_set_buffering_mode symbol public

2490. By Alexandros Frantzis on 2015-04-16

client,server: Allow clients to specify the buffering mode for their surface

=== modified file 'include/client/mir_toolkit/mir_surface.h'
--- include/client/mir_toolkit/mir_surface.h	2015-04-14 11:29:11 +0000
+++ include/client/mir_toolkit/mir_surface.h	2015-04-17 13:13:57 +0000
@@ -323,6 +323,14 @@
 bool mir_surface_spec_set_preferred_orientation(MirSurfaceSpec* spec, MirOrientationMode mode);
 
 /**
+ * Set the requested buffering mode.
+ * \param [in] spec    Specification to mutate
+ * \param [in] mode    Requested buffering mode
+ * \return             False if buffering mode is not a valid attribute of this surface type.
+ */
+bool mir_surface_spec_set_buffering_mode(MirSurfaceSpec* spec, MirBufferingMode mode);
+
+/**
  * Release the resources held by a MirSurfaceSpec.
  *
  * \param [in] spec     Specification to release

=== modified file 'include/common/mir_toolkit/common.h'
--- include/common/mir_toolkit/common.h	2015-03-31 02:35:42 +0000
+++ include/common/mir_toolkit/common.h	2015-04-17 13:13:57 +0000
@@ -166,6 +166,13 @@
     mir_edge_attachment_any = mir_edge_attachment_vertical |
                               mir_edge_attachment_horizontal
 } MirEdgeAttachment;
+
+typedef enum MirBufferingMode
+{
+    mir_buffering_mode_default = 0,
+    mir_buffering_mode_double = 2,
+    mir_buffering_mode_triple = 3
+} MirBufferingMode;
 /**@}*/
 
 #endif

=== modified file 'include/server/mir/scene/surface_creation_parameters.h'
--- include/server/mir/scene/surface_creation_parameters.h	2015-04-14 10:23:11 +0000
+++ include/server/mir/scene/surface_creation_parameters.h	2015-04-17 13:13:57 +0000
@@ -87,6 +87,7 @@
     mir::optional_value<frontend::SurfaceId> parent_id;
     mir::optional_value<geometry::Rectangle> aux_rect;
     mir::optional_value<MirEdgeAttachment> edge_attachment;
+    mir::optional_value<MirBufferingMode> buffering_mode;
 
     std::weak_ptr<Surface> parent;
 

=== modified file 'src/client/mir_surface.cpp'
--- src/client/mir_surface.cpp	2015-04-14 11:29:11 +0000
+++ src/client/mir_surface.cpp	2015-04-17 13:13:57 +0000
@@ -96,6 +96,7 @@
     SERIALIZE_OPTION_IF_SET(min_height, message);
     SERIALIZE_OPTION_IF_SET(max_width, message);
     SERIALIZE_OPTION_IF_SET(max_height, message);
+    SERIALIZE_OPTION_IF_SET(buffering_mode, message);
 
     if (parent.is_set() && parent.value() != nullptr)
         message.set_parent_id(parent.value()->id());
@@ -563,6 +564,7 @@
     COPY_IF_SET(min_height);
     COPY_IF_SET(max_width);
     COPY_IF_SET(max_height);
+    COPY_IF_SET(buffering_mode);
     #undef COPY_IF_SET
 
     if (spec.surface_name.is_set())

=== modified file 'src/client/mir_surface.h'
--- src/client/mir_surface.h	2015-04-09 15:59:52 +0000
+++ src/client/mir_surface.h	2015-04-17 13:13:57 +0000
@@ -75,6 +75,7 @@
     mir::optional_value<int> height;
     mir::optional_value<MirPixelFormat> pixel_format;
     mir::optional_value<MirBufferUsage> buffer_usage;
+    mir::optional_value<MirBufferingMode> buffering_mode;
 
     mir::optional_value<std::string> surface_name;
     mir::optional_value<uint32_t> output_id;

=== modified file 'src/client/mir_surface_api.cpp'
--- src/client/mir_surface_api.cpp	2015-04-16 08:32:47 +0000
+++ src/client/mir_surface_api.cpp	2015-04-17 13:13:57 +0000
@@ -224,6 +224,12 @@
     return true;
 }
 
+bool mir_surface_spec_set_buffering_mode(MirSurfaceSpec* spec, MirBufferingMode mode)
+{
+    spec->buffering_mode = mode;
+    return true;
+}
+
 void mir_surface_spec_release(MirSurfaceSpec* spec)
 {
     delete spec;

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2015-04-16 08:32:47 +0000
+++ src/client/symbols.map	2015-04-17 13:13:57 +0000
@@ -163,6 +163,7 @@
     mir_surface_event_get_attribute;
     mir_surface_event_get_attribute_value;
     mir_surface_set_swapinterval;
+    mir_surface_spec_set_buffering_mode;
     mir_surface_spec_set_min_width;
     mir_surface_spec_set_min_height;
     mir_surface_spec_set_max_width;

=== modified file 'src/protobuf/mir_protobuf.proto'
--- src/protobuf/mir_protobuf.proto	2015-04-14 10:23:11 +0000
+++ src/protobuf/mir_protobuf.proto	2015-04-17 13:13:57 +0000
@@ -31,6 +31,8 @@
   optional int32 min_height = 14;
   optional int32 max_width = 15;
   optional int32 max_height = 16;
+
+  optional int32 buffering_mode = 17;
 }
 
 // If and when we break our protocol backward-compatibility, this could be
@@ -53,6 +55,8 @@
   optional int32 min_height = 14;
   optional int32 max_width = 15;
   optional int32 max_height = 16;
+
+  optional int32 buffering_mode = 17;
 }
 
 

=== modified file 'src/server/frontend/session_mediator.cpp'
--- src/server/frontend/session_mediator.cpp	2015-04-16 20:59:36 +0000
+++ src/server/frontend/session_mediator.cpp	2015-04-17 13:13:57 +0000
@@ -239,6 +239,7 @@
     COPY_IF_SET(min_height);
     COPY_IF_SET(max_width);
     COPY_IF_SET(max_height);
+    COPY_IF_SET(buffering_mode);
 
     #undef COPY_IF_SET
 

=== modified file 'src/server/scene/surface_allocator.cpp'
--- src/server/scene/surface_allocator.cpp	2015-03-31 02:35:42 +0000
+++ src/server/scene/surface_allocator.cpp	2015-04-17 13:13:57 +0000
@@ -58,9 +58,17 @@
     mg::BufferProperties buffer_properties{params.size,
                                            params.pixel_format,
                                            params.buffer_usage};
+    int buffers = nbuffers;
+    if (params.buffering_mode.is_set())
+    {
+        if (params.buffering_mode.value() == mir_buffering_mode_double)
+            buffers = 2;
+        else if (params.buffering_mode.value() == mir_buffering_mode_triple)
+            buffers = 3;
+    }
+
     auto buffer_stream = buffer_stream_factory->create_buffer_stream(
-        nbuffers,
-        buffer_properties);
+        buffers, buffer_properties);
     auto actual_size = geom::Rectangle{params.top_left, buffer_stream->stream_size()};
 
     bool nonrectangular = has_alpha(params.pixel_format);

=== modified file 'src/server/scene/surface_creation_parameters.cpp'
--- src/server/scene/surface_creation_parameters.cpp	2015-01-23 03:50:26 +0000
+++ src/server/scene/surface_creation_parameters.cpp	2015-04-17 13:13:57 +0000
@@ -151,6 +151,7 @@
         lhs.state == rhs.state &&
         lhs.type == rhs.type &&
         lhs.preferred_orientation == rhs.preferred_orientation &&
+        lhs.buffering_mode == rhs.buffering_mode &&
         lhs.parent_id == rhs.parent_id;
 }
 

=== modified file 'tests/acceptance-tests/CMakeLists.txt'
--- tests/acceptance-tests/CMakeLists.txt	2015-04-09 06:20:31 +0000
+++ tests/acceptance-tests/CMakeLists.txt	2015-04-17 13:13:57 +0000
@@ -41,6 +41,7 @@
   test_shell_control_of_surface_configuration.cpp
   test_render_override.cpp
   test_surface_modifications.cpp
+  test_client_surface_buffering_mode.cpp
 )
 
 if (MIR_TEST_PLATFORM STREQUAL "mesa")

=== added file 'tests/acceptance-tests/test_client_surface_buffering_mode.cpp'
--- tests/acceptance-tests/test_client_surface_buffering_mode.cpp	1970-01-01 00:00:00 +0000
+++ tests/acceptance-tests/test_client_surface_buffering_mode.cpp	2015-04-17 13:13:57 +0000
@@ -0,0 +1,133 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#include "mir_toolkit/mir_client_library.h"
+#include "mir_toolkit/debug/surface.h"
+
+#include "mir_test_framework/connected_client_headless_server.h"
+#include "mir_test_framework/stub_server_platform_factory.h"
+
+#include <unordered_set>
+#include <chrono>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mtf = mir_test_framework;
+
+using namespace std::literals::chrono_literals;
+
+namespace
+{
+
+struct WithDefaultSurfaceBuffers : mtf::ConnectedClientHeadlessServer,
+                                   ::testing::WithParamInterface<int>
+{
+    WithDefaultSurfaceBuffers()
+    {
+        add_to_environment("MIR_SERVER_NBUFFERS", std::to_string(GetParam()).c_str());
+        // In triple buffering mode the server initially allocates only two buffers,
+        // and the third on demand. We use a non-zero vsync interval so that the client
+        // can swap buffers faster than the server can process them, which forces the
+        // server to allocate all surface buffers.
+        mtf::set_next_vsync_interval(5ms);
+    }
+
+    template<typename T> using UPtr = std::unique_ptr<T,void(*)(T*)>;
+
+    UPtr<MirSurface> create_surface_with_buffering_mode(MirBufferingMode mode)
+    {
+        auto const spec = UPtr<MirSurfaceSpec>{
+            mir_connection_create_spec_for_normal_surface(
+                connection, 640, 480, mir_pixel_format_argb_8888),
+            mir_surface_spec_release};
+
+        mir_surface_spec_set_buffering_mode(spec.get(), mode);
+
+        return UPtr<MirSurface>{
+            mir_surface_create_sync(spec.get()), mir_surface_release_sync};
+    }
+
+    UPtr<MirSurface> create_surface_without_buffering_mode()
+    {
+        auto const spec = UPtr<MirSurfaceSpec>{
+            mir_connection_create_spec_for_normal_surface(
+                connection, 640, 480, mir_pixel_format_argb_8888),
+            mir_surface_spec_release};
+
+        return UPtr<MirSurface>{
+            mir_surface_create_sync(spec.get()), mir_surface_release_sync};
+    }
+
+    unsigned int number_of_buffers_for(MirSurface* surface)
+    {
+        std::unordered_set<uint32_t> buffers;
+
+        for (int i = 0; i != 10; ++i)
+        {
+            mir_buffer_stream_swap_buffers_sync(
+                mir_surface_get_buffer_stream(surface));
+            buffers.insert(
+                mir_debug_surface_current_buffer_id(surface));
+        }
+
+        return buffers.size();
+    }
+};
+
+}
+
+TEST_P(WithDefaultSurfaceBuffers, allocates_two_buffers_when_client_requests_double_buffering)
+{
+    using namespace testing;
+
+    auto const surface = create_surface_with_buffering_mode(mir_buffering_mode_double);
+
+    EXPECT_THAT(number_of_buffers_for(surface.get()), Eq(2));
+}
+
+TEST_P(WithDefaultSurfaceBuffers, allocates_three_buffers_when_client_requests_triple_buffering)
+{
+    using namespace testing;
+
+    auto const surface = create_surface_with_buffering_mode(mir_buffering_mode_triple);
+
+    EXPECT_THAT(number_of_buffers_for(surface.get()), Eq(3));
+}
+
+TEST_P(WithDefaultSurfaceBuffers, allocates_default_buffers_when_client_requests_default_buffering)
+{
+    using namespace testing;
+
+    auto const surface = create_surface_with_buffering_mode(mir_buffering_mode_default);
+
+    EXPECT_THAT(number_of_buffers_for(surface.get()), Eq(GetParam()));
+}
+
+TEST_P(WithDefaultSurfaceBuffers, allocates_default_buffers_when_client_does_not_specify_buffering)
+{
+    using namespace testing;
+
+    auto const surface = create_surface_without_buffering_mode();
+
+    EXPECT_THAT(number_of_buffers_for(surface.get()), Eq(GetParam()));
+}
+
+INSTANTIATE_TEST_CASE_P(MirServer,
+                        WithDefaultSurfaceBuffers,
+                        ::testing::Values(2,3));

=== modified file 'tests/include/mir_test_doubles/null_display_sync_group.h'
--- tests/include/mir_test_doubles/null_display_sync_group.h	2015-02-20 19:44:17 +0000
+++ tests/include/mir_test_doubles/null_display_sync_group.h	2015-04-17 13:13:57 +0000
@@ -24,6 +24,7 @@
 #include "null_display_buffer.h"
 #include "stub_display_buffer.h"
 #include <thread>
+#include <chrono>
 
 namespace mir
 {
@@ -36,12 +37,23 @@
 {
 public:
     StubDisplaySyncGroup(std::vector<geometry::Rectangle> const& output_rects)
-        : output_rects{output_rects}
+        : StubDisplaySyncGroup(output_rects, std::chrono::milliseconds{0})
+    {
+    }
+
+    StubDisplaySyncGroup(geometry::Size sz)
+        : StubDisplaySyncGroup({{{0,0}, sz}}, std::chrono::milliseconds{0})
+    {
+    }
+
+    StubDisplaySyncGroup(std::vector<geometry::Rectangle> const& output_rects,
+                         std::chrono::milliseconds vsync_interval)
+        : output_rects{output_rects},
+          vsync_interval{vsync_interval}
     {
         for (auto const& output_rect : output_rects)
             display_buffers.emplace_back(output_rect);
     }
-    StubDisplaySyncGroup(geometry::Size sz) : StubDisplaySyncGroup({{{0,0}, sz}}) {}
 
     void for_each_display_buffer(std::function<void(graphics::DisplayBuffer&)> const& f) override
     {
@@ -52,12 +64,16 @@
     void post() override
     {
         /* yield() is needed to ensure reasonable runtime under valgrind for some tests */
-        std::this_thread::yield();
+        if (vsync_interval == vsync_interval.zero())
+            std::this_thread::yield();
+        else
+            std::this_thread::sleep_for(vsync_interval);
     }
 
 private:
     std::vector<geometry::Rectangle> const output_rects;
     std::vector<StubDisplayBuffer> display_buffers;
+    std::chrono::milliseconds vsync_interval{0};
 };
 
 struct NullDisplaySyncGroup : graphics::DisplaySyncGroup

=== modified file 'tests/include/mir_test_doubles/stub_display.h'
--- tests/include/mir_test_doubles/stub_display.h	2015-03-31 02:35:42 +0000
+++ tests/include/mir_test_doubles/stub_display.h	2015-04-17 13:13:57 +0000
@@ -27,6 +27,7 @@
 #include "mir/geometry/rectangle.h"
 
 #include <vector>
+#include <chrono>
 
 namespace mir
 {
@@ -39,15 +40,21 @@
 {
 public:
     StubDisplay(std::vector<geometry::Rectangle> const& output_rects) :
+        StubDisplay(output_rects, std::chrono::milliseconds::zero())
+    {
+    }
+
+    StubDisplay(unsigned int nbuffers) :
+        StubDisplay(generate_stub_rects(nbuffers))
+    {
+    }
+
+    StubDisplay(std::vector<geometry::Rectangle> const& output_rects,
+                std::chrono::milliseconds vsync_interval) :
         output_rects(output_rects)
     {
         for (auto const& rect : output_rects)
-            groups.emplace_back(new StubDisplaySyncGroup({rect}));
-    }
-
-    StubDisplay(unsigned int nbuffers) :
-        StubDisplay(generate_stub_rects(nbuffers))
-    {
+            groups.emplace_back(new StubDisplaySyncGroup({rect}, vsync_interval));
     }
 
     void for_each_display_sync_group(std::function<void(graphics::DisplaySyncGroup&)> const& f) override

=== modified file 'tests/include/mir_test_framework/stub_server_platform_factory.h'
--- tests/include/mir_test_framework/stub_server_platform_factory.h	2015-04-09 06:20:31 +0000
+++ tests/include/mir_test_framework/stub_server_platform_factory.h	2015-04-17 13:13:57 +0000
@@ -26,6 +26,7 @@
 #include <vector>
 #include <memory>
 #include <string>
+#include <chrono>
 
 namespace geom = mir::geometry;
 
@@ -53,6 +54,8 @@
 
 void set_next_preset_display(std::shared_ptr<mir::graphics::Display> const& display);
 
+void set_next_vsync_interval(std::chrono::milliseconds interval);
+
 mir::UniqueModulePtr<FakeInputDevice> add_fake_input_device(mir::input::InputDeviceInfo const& info);
 }
 #endif /* MIR_TEST_FRAMEWORK_STUB_SERVER_PLATFORM_FACTORY_ */

=== modified file 'tests/mir_test_framework/stub_server_platform_factory.cpp'
--- tests/mir_test_framework/stub_server_platform_factory.cpp	2015-04-09 06:20:31 +0000
+++ tests/mir_test_framework/stub_server_platform_factory.cpp	2015-04-17 13:13:57 +0000
@@ -87,3 +87,16 @@
 
     return add_device(info);
 }
+
+void mtf::set_next_vsync_interval(
+    std::chrono::milliseconds interval)
+{
+    ensure_platform_library();
+
+    using func_sig = void(*)(std::chrono::milliseconds);
+
+    auto const set_next_vsync_interval =
+        platform_graphics_lib->load_function<func_sig>("set_next_vsync_interval");
+
+    return set_next_vsync_interval(interval);
+}

=== modified file 'tests/mir_test_framework/stubbed_graphics_platform.cpp'
--- tests/mir_test_framework/stubbed_graphics_platform.cpp	2015-03-31 02:35:42 +0000
+++ tests/mir_test_framework/stubbed_graphics_platform.cpp	2015-04-17 13:13:57 +0000
@@ -228,6 +228,7 @@
 namespace
 {
 std::shared_ptr<mg::Display> display_preset;
+std::chrono::milliseconds vsync_interval;
 }
 
 std::shared_ptr<mg::Display> mtf::StubGraphicPlatform::create_display(
@@ -238,7 +239,9 @@
     if (display_preset)
         return std::move(display_preset);
 
-    return std::make_shared<mtd::StubDisplay>(display_rects);
+    auto const tmp_vsync = vsync_interval;
+    vsync_interval = std::chrono::milliseconds::zero();
+    return std::make_shared<mtd::StubDisplay>(display_rects, tmp_vsync);
 }
 
 namespace
@@ -334,3 +337,8 @@
 {
     display_preset = display;
 }
+
+extern "C" void set_next_vsync_interval(std::chrono::milliseconds interval)
+{
+    vsync_interval = interval;
+}