Merge lp:~vanvugt/mir/timerless-multimonitor-frame-sync into lp:~mir-team/mir/trunk

[Daniel van Vugt]

Dramatically improved multi-monitor frame synchronization, using a global
frame count equivalent to the highest refresh rate of all monitors. This is
much more reliable than the old logic which was based on timers.

This fixes LP: #1210478

This version depends on the bypass branch in order to minimize conflicts. But I can remove that dependency if required.

Also, this branch conflicts with lp:~vanvugt/mir/remove-unused-buffer-methods.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:948
http://jenkins.qa.ubuntu.com/job/mir-ci/1392/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1865
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1750
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/630
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/630/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Chris Halse Rogers (raof)]

Mostly looks good to me, only nitpick:

160 + local_frame_count <= 0) // Wrap around, unlikely, but handle it...

I'm not a huge fan of testing unsigned values for <= 0. Maybe make it == 0?

[Daniel van Vugt (vanvugt)]

I prefer to keep "<= 0". It's extra protection against regressions if anyone changes it to signed in future.

[Daniel van Vugt (vanvugt)]

I have what looks like a test setup to reproduce LP: #1216472 now, and it looks like it is not fixed by this :(

[Alan Griffiths (alan-griffiths)]

I like the approach, but some small concerns:

159 + if (global_frame_count.load() < local_frame_count ||
160 + local_frame_count <= 0) // Wrap around, unlikely, but handle it...
161 + {
162 + global_frame_count.store(local_frame_count);
163 + }
164 + else
165 + {
166 + local_frame_count = global_frame_count.load();
167 + }

As there is no synchronization between the first load and the store I don't think the logic is mathematically correct. Could we improve on this by using compare_exchange? (Not that I think there's much chance of a problem in practice.)

~~~~

134 +std::atomic_ulong mc::DefaultDisplayBufferCompositor::global_frame_count(0);

There's no reason for this to be "published" in a header: it could be a namespace scope variable (in anonymous namespace) rather than a static class member.

~~~~

I don't have a better name but "frameno" doesn't really indicate what the parameter is for.

review: Needs Information

[Daniel van Vugt (vanvugt)]

Alan, I was thinking the same. Just haven't got to it yet.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:950
http://jenkins.qa.ubuntu.com/job/mir-ci/1399/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1876
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1761
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/637
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/637/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

Alternatively, see:
https://code.launchpad.net/~vanvugt/mir/timerless-multimonitor-frame-sync-without-bypass/+merge/182540
which is not blocked by bypass.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:952
http://jenkins.qa.ubuntu.com/job/mir-ci/1418/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/1908
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/1793
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/656
        deb: http://jenkins.qa.ubuntu.com/job/mir-saucy-amd64-ci/656/artifact/work/output/*zip*/output.zip

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Review: Needs Fixing

162 + if (global_frame_count < local_frame_count || local_frame_count <= 0)
163 + global_frame_count = local_frame_count;
164 + else
165 + local_frame_count = global_frame_count;
166 + }

Start with:

thread 1: local_frame_count = MAX_UNIT
thread 2: local_frame_count = MAX_UNIT-1

thread 1 runs through this code leaving:

global_frame_count == (t1)local_frame_count == 0

Then thread 2 runs through it leaving:

global_frame_count == (t2)local_frame_count == MAX_UNIT

When the result needed by the algorithm is:

global_frame_count == (t2)local_frame_count == 0

Things do sort themselves out and the error is mostly harmless (and only occurs occasionally) but it could be improved upon. Vis:

162 + if (global_frame_count < local_frame_count || local_frame_count <= 0)
          if (global_frame_count - local_frame_count > UNIT_MAX/2)

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

I'm still not entirely happy with the naming - frameno, global_frame_count and local_frame_count are not really what their names suggest. They are neither identifiers nor counts but actually sequence numbers.

=== modified file 'include/server/mir/compositor/buffer_stream_surfaces.h'
--- include/server/mir/compositor/buffer_stream_surfaces.h	2013-08-09 01:37:53 +0000
+++ include/server/mir/compositor/buffer_stream_surfaces.h	2013-08-29 09:10:29 +0000
@@ -41,7 +41,8 @@
 
     std::shared_ptr<graphics::Buffer> secure_client_buffer();
 
-    std::shared_ptr<graphics::Buffer> lock_compositor_buffer() override;
+    std::shared_ptr<graphics::Buffer>
+        lock_compositor_buffer(unsigned long frameno) override;
     std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() override;
 
     geometry::PixelFormat get_stream_pixel_format();
 
=== modified file 'include/server/mir/compositor/renderer.h'
--- include/server/mir/compositor/renderer.h	2013-08-09 01:37:53 +0000
+++ include/server/mir/compositor/renderer.h	2013-08-29 09:10:29 +0000
@@ -37,7 +37,7 @@
 public:
     virtual ~Renderer() = default;
 
-    virtual void clear() = 0;
+    virtual void clear(unsigned long frameno) = 0;
     virtual void render(std::function<void(std::shared_ptr<void> const&)> save_resource,
                                            CompositingCriteria const& info, surfaces::BufferStream& stream) = 0;
 
 
=== modified file 'include/server/mir/surfaces/buffer_stream.h'
--- include/server/mir/surfaces/buffer_stream.h	2013-08-09 01:37:53 +0000
+++ include/server/mir/surfaces/buffer_stream.h	2013-08-29 09:10:29 +0000
@@ -42,7 +42,8 @@
     virtual ~BufferStream() {/* TODO: make nothrow */}
 
     virtual std::shared_ptr<graphics::Buffer> secure_client_buffer() = 0;
-    virtual std::shared_ptr<graphics::Buffer> lock_compositor_buffer() = 0;
+    virtual std::shared_ptr<graphics::Buffer>
+        lock_compositor_buffer(unsigned long frameno) = 0;
     virtual std::shared_ptr<graphics::Buffer> lock_snapshot_buffer() = 0;
     virtual geometry::PixelFormat get_stream_pixel_format() = 0;
     virtual geometry::Size stream_size() = 0;
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_bundle.h'
--- include/test/mir_test_doubles/mock_buffer_bundle.h	2013-08-09 01:37:53 +0000
+++ include/test/mir_test_doubles/mock_buffer_bundle.h	2013-08-29 09:10:29 +0000
@@ -39,7 +39,7 @@
 
     MOCK_METHOD0(client_acquire,     std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(client_release,     void(std::shared_ptr<graphics::Buffer> const&));
-    MOCK_METHOD0(compositor_acquire, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(compositor_acquire, std::shared_ptr<graphics::Buffer>(unsigned long));
     MOCK_METHOD1(compositor_release, void(std::shared_ptr<graphics::Buffer> const&));
     MOCK_METHOD0(snapshot_acquire, std::shared_ptr<graphics::Buffer>());
     MOCK_METHOD1(snapshot_release, void(std::shared_ptr<graphics::Buffer> const&));
 
=== modified file 'include/test/mir_test_doubles/mock_buffer_stream.h'
--- include/test/mir_test_doubles/mock_buffer_stream.h	2013-08-09 01:37:53 +0000
+++ include/test/mir_test_doubles/mock_buffer_stream.h	2013-08-29 09:10:29 +0000
@@ -32,7 +32,8 @@
 struct MockBufferStream : public surfaces::BufferStream
 {
     MOCK_METHOD0(secure_client_buffer, std::shared_ptr<graphics::Buffer>());
-    MOCK_METHOD0(lock_compositor_buffer, std::shared_ptr<graphics::Buffer>());
+    MOCK_METHOD1(lock_compositor_buffer,
+                 std::shared_ptr<graphics::Buffer>(unsigned long));
     MOCK_METHOD0(lock_snapshot_buffer, std::shared_ptr<graphics::Buffer>());
 
     MOCK_METHOD0(get_stream_pixel_format, geometry::PixelFormat());
 
=== modified file 'include/test/mir_test_doubles/mock_surface_renderer.h'
--- include/test/mir_test_doubles/mock_surface_renderer.h	2013-08-09 01:37:53 +0000
+++ include/test/mir_test_doubles/mock_surface_renderer.h	2013-08-29 09:10:29 +0000
@@ -33,7 +33,7 @@
 {
     MOCK_METHOD3(render, void(
         std::function<void(std::shared_ptr<void> const&)>, compositor::CompositingCriteria const&, surfaces::BufferStream&));
-    MOCK_METHOD0(clear, void());
+    MOCK_METHOD1(clear, void(unsigned long));
 
     ~MockSurfaceRenderer() noexcept {}
 };
 
=== modified file 'include/test/mir_test_doubles/stub_buffer_stream.h'
--- include/test/mir_test_doubles/stub_buffer_stream.h	2013-08-09 01:37:53 +0000
+++ include/test/mir_test_doubles/stub_buffer_stream.h	2013-08-29 09:10:29 +0000
@@ -42,7 +42,7 @@
         return stub_client_buffer;
     }
 
-    std::shared_ptr<graphics::Buffer> lock_compositor_buffer()
+    std::shared_ptr<graphics::Buffer> lock_compositor_buffer(unsigned long)
     {
         return stub_compositor_buffer;
     }
 
=== modified file 'src/server/compositor/buffer_bundle.h'
--- src/server/compositor/buffer_bundle.h	2013-08-09 01:37:53 +0000
+++ src/server/compositor/buffer_bundle.h	2013-08-29 09:10:29 +0000
@@ -36,7 +36,8 @@
     virtual ~BufferBundle() noexcept {}
     virtual std::shared_ptr<graphics::Buffer> client_acquire() = 0;
     virtual void client_release(std::shared_ptr<graphics::Buffer> const&) = 0;
-    virtual std::shared_ptr<graphics::Buffer> compositor_acquire() = 0;
+    virtual std::shared_ptr<graphics::Buffer>
+        compositor_acquire(unsigned long frameno) = 0;
     virtual void compositor_release(std::shared_ptr<graphics::Buffer> const&) = 0;
     virtual std::shared_ptr<graphics::Buffer> snapshot_acquire() = 0;
     virtual void snapshot_release(std::shared_ptr<graphics::Buffer> const&) = 0;
 
=== modified file 'src/server/compositor/buffer_stream_surfaces.cpp'
--- src/server/compositor/buffer_stream_surfaces.cpp	2013-08-09 01:37:53 +0000
+++ src/server/compositor/buffer_stream_surfaces.cpp	2013-08-29 09:10:29 +0000
@@ -37,9 +37,11 @@
     force_requests_to_complete();
 }
 
-std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer()
+std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_compositor_buffer(
+    unsigned long frameno)
 {
-    return std::make_shared<mc::TemporaryCompositorBuffer>(buffer_bundle);
+    return std::make_shared<mc::TemporaryCompositorBuffer>(
+        buffer_bundle, frameno);
 }
 
 std::shared_ptr<mg::Buffer> mc::BufferStreamSurfaces::lock_snapshot_buffer()
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2013-08-26 03:21:56 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2013-08-29 09:10:29 +0000
@@ -49,6 +49,14 @@
     mir::geometry::Rectangle const& enclosing_region;
 };
 
+std::mutex global_frameno_lock;
+unsigned long global_frameno = 0;
+
+bool wrapped_greater_or_equal(unsigned long a, unsigned long b)
+{
+    return (a - b) < (~0UL / 2UL);
+}
+
 }
 
 mc::DefaultDisplayBufferCompositor::DefaultDisplayBufferCompositor(
@@ -59,16 +67,32 @@
     : mc::BasicDisplayBufferCompositor{display_buffer},
       scene{scene},
       renderer{renderer},
-      overlay_renderer{overlay_renderer}
+      overlay_renderer{overlay_renderer},
+      local_frameno{global_frameno}
 {
 }
 
+
 void mc::DefaultDisplayBufferCompositor::composite()
 {
     static bool got_bypass_env = false;
     static bool bypass_env = true;
     bool bypassed = false;
 
+    /*
+     * Increment frame counts for each tick of the fastest instance of
+     * DefaultDisplayBufferCompositor. This means for the fastest refresh
+     * rate of all attached outputs.
+     */
+    local_frameno++;
+    {
+        std::lock_guard<std::mutex> lock(global_frameno_lock);
+        if (wrapped_greater_or_equal(local_frameno, global_frameno))
+            global_frameno = local_frameno;
+        else
+            local_frameno = global_frameno;
+    }
+
     if (!got_bypass_env)
     {
         const char *env = getenv("MIR_BYPASS");
@@ -91,7 +115,8 @@
         if (filter.fullscreen_on_top())
         {
             auto bypass_buf =
-                match.topmost_fullscreen()->lock_compositor_buffer();
+                match.topmost_fullscreen()->lock_compositor_buffer(
+                    local_frameno);
 
             if (bypass_buf->can_bypass())
             {
@@ -110,7 +135,7 @@
     mir::geometry::Rectangle const& view_area,
     std::function<void(std::shared_ptr<void> const&)> save_resource)
 {
-    renderer->clear();
+    renderer->clear(local_frameno);
 
     mc::RenderingOperator applicator(*renderer, save_resource);
     FilterForVisibleSceneInRegion selector(view_area);
 
=== modified file 'src/server/compositor/default_display_buffer_compositor.h'
--- src/server/compositor/default_display_buffer_compositor.h	2013-07-25 04:18:04 +0000
+++ src/server/compositor/default_display_buffer_compositor.h	2013-08-29 09:10:29 +0000
@@ -53,6 +53,8 @@
     std::shared_ptr<Scene> const scene;
     std::shared_ptr<Renderer> const renderer;
     std::shared_ptr<OverlayRenderer> const overlay_renderer;
+
+    unsigned long local_frameno;
 };
 
 }
 
=== modified file 'src/server/compositor/gl_renderer.cpp'
--- src/server/compositor/gl_renderer.cpp	2013-08-23 01:44:53 +0000
+++ src/server/compositor/gl_renderer.cpp	2013-08-29 09:10:29 +0000
@@ -235,6 +235,7 @@
 }
 
 mc::GLRenderer::GLRenderer(geom::Rectangle const& display_area)
+    : frameno{0}
 {
     resources.setup(display_area);
 }
@@ -265,7 +266,7 @@
     /* Use the renderable's texture */
     glBindTexture(GL_TEXTURE_2D, resources.texture);
 
-    auto region_resource = stream.lock_compositor_buffer();
+    auto region_resource = stream.lock_compositor_buffer(frameno);
     region_resource->bind_to_texture();
     save_resource(region_resource);
 
@@ -277,8 +278,9 @@
     glDisableVertexAttribArray(resources.position_attr_loc);
 }
 
-void mc::GLRenderer::clear()
+void mc::GLRenderer::clear(unsigned long frame)
 {
+    frameno = frame;
     glClear(GL_COLOR_BUFFER_BIT);
 }
 
 
=== modified file 'src/server/compositor/gl_renderer.h'
--- src/server/compositor/gl_renderer.h	2013-08-09 01:37:53 +0000
+++ src/server/compositor/gl_renderer.h	2013-08-29 09:10:29 +0000
@@ -36,7 +36,7 @@
     /* From renderer */
     void render(std::function<void(std::shared_ptr<void> const&)> save_resource,
                                    CompositingCriteria const& info, surfaces::BufferStream& stream);
-    void clear();
+    void clear(unsigned long frameno) override;
 
     ~GLRenderer() noexcept {}
 
@@ -60,6 +60,8 @@
     };
 
     Resources resources;
+
+    unsigned long frameno;
 };
 
 }
 
=== modified file 'src/server/compositor/switching_bundle.cpp'
--- src/server/compositor/switching_bundle.cpp	2013-08-09 01:37:53 +0000
+++ src/server/compositor/switching_bundle.cpp	2013-08-29 09:10:29 +0000
@@ -76,6 +76,7 @@
       first_ready{0}, nready{0},
       first_client{0}, nclients{0},
       snapshot{-1}, nsnapshotters{0},
+      last_consumed{0},
       overlapping_compositors{false},
       framedropping{false}, force_drop{0}
 {
@@ -85,8 +86,6 @@
                                                "nbuffers betwee 1 and " +
                                                std::to_string(MAX_NBUFFERS)));
     }
-
-    last_consumed = now() - std::chrono::seconds(1);
 }
 
 int mc::SwitchingBundle::nfree() const
@@ -259,15 +258,14 @@
     cond.notify_all();
 }
 
-std::shared_ptr<mg::Buffer> mc::SwitchingBundle::compositor_acquire()
+std::shared_ptr<mg::Buffer> mc::SwitchingBundle::compositor_acquire(
+    unsigned long frameno)
 {
     std::unique_lock<std::mutex> lock(guard);
     int compositor;
 
-    auto t = now();
-
     // Multi-monitor acquires close to each other get the same frame:
-    bool same_frame = (t - last_consumed) < std::chrono::milliseconds(10);
+    bool same_frame = (frameno == last_consumed);
 
     int avail = nfree();
     bool can_recycle = ncompositors || avail;
@@ -296,7 +294,7 @@
         first_ready = next(first_ready);
         nready--;
         ncompositors++;
-        last_consumed = t;
+        last_consumed = frameno;
     }
 
     overlapping_compositors = (ncompositors > 1);
 
=== modified file 'src/server/compositor/switching_bundle.h'
--- src/server/compositor/switching_bundle.h	2013-08-09 01:37:53 +0000
+++ src/server/compositor/switching_bundle.h	2013-08-29 09:10:29 +0000
@@ -24,7 +24,6 @@
 #include <condition_variable>
 #include <mutex>
 #include <memory>
-#include <chrono>
 
 namespace mir
 {
@@ -47,7 +46,8 @@
 
     std::shared_ptr<graphics::Buffer> client_acquire();
     void client_release(std::shared_ptr<graphics::Buffer> const&);
-    std::shared_ptr<graphics::Buffer> compositor_acquire();
+    std::shared_ptr<graphics::Buffer>
+        compositor_acquire(unsigned long frameno) override;
     void compositor_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
     std::shared_ptr<graphics::Buffer> snapshot_acquire();
     void snapshot_release(std::shared_ptr<graphics::Buffer> const& released_buffer);
@@ -89,10 +89,7 @@
     std::mutex guard;
     std::condition_variable cond;
 
-    typedef std::chrono::high_resolution_clock::time_point time_point;
-    static time_point now()
-        { return std::chrono::high_resolution_clock::now(); }
-    time_point last_consumed;
+    unsigned long last_consumed;
 
     bool overlapping_compositors;
 
 
=== modified file 'src/server/compositor/temporary_buffers.cpp'
--- src/server/compositor/temporary_buffers.cpp	2013-08-13 07:56:50 +0000
+++ src/server/compositor/temporary_buffers.cpp	2013-08-29 09:10:29 +0000
@@ -41,8 +41,8 @@
 }
 
 mc::TemporaryCompositorBuffer::TemporaryCompositorBuffer(
-    std::shared_ptr<BufferBundle> const& bun)
-    : TemporaryBuffer(bun->compositor_acquire()),
+    std::shared_ptr<BufferBundle> const& bun, unsigned long frameno)
+    : TemporaryBuffer(bun->compositor_acquire(frameno)),
       bundle(bun)
 {
 }
 
=== modified file 'src/server/compositor/temporary_buffers.h'
--- src/server/compositor/temporary_buffers.h	2013-08-13 07:56:50 +0000
+++ src/server/compositor/temporary_buffers.h	2013-08-29 09:10:29 +0000
@@ -62,7 +62,7 @@
 {
 public:
     explicit TemporaryCompositorBuffer(
-        std::shared_ptr<BufferBundle> const& bun);
+        std::shared_ptr<BufferBundle> const& bun, unsigned long frameno);
     ~TemporaryCompositorBuffer();
 
 private:
 
=== modified file 'src/server/surfaces/surface.cpp'
--- src/server/surfaces/surface.cpp	2013-08-09 01:37:53 +0000
+++ src/server/surfaces/surface.cpp	2013-08-29 09:10:29 +0000
@@ -125,7 +125,7 @@
 
 std::shared_ptr<mg::Buffer> ms::Surface::compositor_buffer() const
 {
-    return surface_buffer_stream->lock_compositor_buffer();
+    return surface_buffer_stream->lock_compositor_buffer(0);
 }
 
 std::shared_ptr<mg::Buffer> ms::Surface::snapshot_buffer() const
 
=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2013-08-26 03:00:33 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2013-08-29 09:10:29 +0000
@@ -58,7 +58,7 @@
         std::this_thread::yield();
     }
 
-    void clear() {}
+    void clear(unsigned long) override {}
 };
 
 
 
=== modified file 'tests/integration-tests/compositor/test_buffer_stream.cpp'
--- tests/integration-tests/compositor/test_buffer_stream.cpp	2013-08-09 01:37:53 +0000
+++ tests/integration-tests/compositor/test_buffer_stream.cpp	2013-08-29 09:10:29 +0000
@@ -64,11 +64,6 @@
     mc::BufferStreamSurfaces buffer_stream;
 };
 
-void sleep_one_frame()
-{
-    std::this_thread::sleep_for(std::chrono::milliseconds(16));
-}
-
 }
 
 TEST_F(BufferStreamTest, gives_same_back_buffer_until_more_available)
@@ -77,8 +72,8 @@
     auto client1_id = client1->id();
     client1.reset();
 
-    auto comp1 = buffer_stream.lock_compositor_buffer();
-    auto comp2 = buffer_stream.lock_compositor_buffer();
+    auto comp1 = buffer_stream.lock_compositor_buffer(1);
+    auto comp2 = buffer_stream.lock_compositor_buffer(1);
 
     EXPECT_EQ(comp1->id(), comp2->id());
     EXPECT_EQ(comp1->id(), client1_id);
@@ -86,8 +81,7 @@
     comp1.reset();
 
     buffer_stream.secure_client_buffer().reset();
-    sleep_one_frame();
-    auto comp3 = buffer_stream.lock_compositor_buffer();
+    auto comp3 = buffer_stream.lock_compositor_buffer(2);
 
     EXPECT_NE(client1_id, comp3->id());
 
@@ -95,7 +89,7 @@
     auto comp3_id = comp3->id();
     comp3.reset();
 
-    auto comp4 = buffer_stream.lock_compositor_buffer();
+    auto comp4 = buffer_stream.lock_compositor_buffer(2);
     EXPECT_EQ(comp3_id, comp4->id());
 }
 
@@ -104,13 +98,13 @@
     for (int i = 0; i < nbuffers - 1; i++)
         buffer_stream.secure_client_buffer().reset();
 
-    auto first_monitor = buffer_stream.lock_compositor_buffer();
+    auto first_monitor = buffer_stream.lock_compositor_buffer(1);
     auto first_compositor_id = first_monitor->id();
     first_monitor.reset();
 
     for (int m = 0; m < 10; m++)
     {
-        auto monitor = buffer_stream.lock_compositor_buffer();
+        auto monitor = buffer_stream.lock_compositor_buffer(1);
         ASSERT_EQ(first_compositor_id, monitor->id());
     }
 }
@@ -120,12 +114,10 @@
     if (nbuffers > 1)
     {
         buffer_stream.secure_client_buffer().reset();
-        auto comp1 = buffer_stream.lock_compositor_buffer();
-
-        sleep_one_frame();
+        auto comp1 = buffer_stream.lock_compositor_buffer(1);
 
         buffer_stream.secure_client_buffer().reset();
-        auto comp2 = buffer_stream.lock_compositor_buffer();
+        auto comp2 = buffer_stream.lock_compositor_buffer(2);
     
         EXPECT_NE(comp1->id(), comp2->id());
     
@@ -139,14 +131,14 @@
     buffer_stream.secure_client_buffer().reset();
     auto client1 = buffer_stream.secure_client_buffer();
 
-    auto comp1 = buffer_stream.lock_compositor_buffer();
-    auto comp2 = buffer_stream.lock_compositor_buffer();
+    auto comp1 = buffer_stream.lock_compositor_buffer(123);
+    auto comp2 = buffer_stream.lock_compositor_buffer(123);
 
     EXPECT_EQ(comp1->id(), comp2->id());
 
     comp1.reset();
 
-    auto comp3 = buffer_stream.lock_compositor_buffer();
+    auto comp3 = buffer_stream.lock_compositor_buffer(123);
 
     EXPECT_EQ(comp2->id(), comp3->id());
 }
@@ -167,13 +159,15 @@
 void compositor_loop(ms::BufferStream &stream,
                      std::atomic<bool> &done)
 {
+    unsigned long count = 0;
+
     while (!done.load())
     {
-        auto comp1 = stream.lock_compositor_buffer();
+        auto comp1 = stream.lock_compositor_buffer(++count);
         ASSERT_NE(nullptr, comp1);
 
         // Also stress test getting a second compositor buffer before yielding
-        auto comp2 = stream.lock_compositor_buffer();
+        auto comp2 = stream.lock_compositor_buffer(count);
         ASSERT_NE(nullptr, comp2);
 
         std::this_thread::yield();
 
=== modified file 'tests/integration-tests/compositor/test_swapping_swappers.cpp'
--- tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-08-09 01:37:53 +0000
+++ tests/integration-tests/compositor/test_swapping_swappers.cpp	2013-08-29 09:10:29 +0000
@@ -72,9 +72,10 @@
     auto g = std::async(std::launch::async,
                 [this]
                 {
+                    unsigned long count = 0;
                     while(!client_thread_done)
                     {
-                        auto b = switching_bundle->compositor_acquire();
+                        auto b = switching_bundle->compositor_acquire(++count);
                         std::this_thread::yield();
                         switching_bundle->compositor_release(b);
                     }
@@ -116,9 +117,10 @@
     auto g = std::async(std::launch::async,
                 [this]
                 {
+                    unsigned long count = 0;
                     while(!client_thread_done)
                     {
-                        auto b = switching_bundle->compositor_acquire();
+                        auto b = switching_bundle->compositor_acquire(++count);
                         std::this_thread::yield();
                         switching_bundle->compositor_release(b);
                     }
 
=== modified file 'tests/integration-tests/shell/test_session.cpp'
--- tests/integration-tests/shell/test_session.cpp	2013-08-12 01:44:15 +0000
+++ tests/integration-tests/shell/test_session.cpp	2013-08-29 09:10:29 +0000
@@ -95,11 +95,11 @@
     {
         struct StubRenderer : public mc::Renderer
         {
-            void clear() {}
+            void clear(unsigned long) override {}
             void render(std::function<void(std::shared_ptr<void> const&)>,
                         mc::CompositingCriteria const&, mir::surfaces::BufferStream& stream)
             {
-                stream.lock_compositor_buffer();
+                stream.lock_compositor_buffer(0);
             }
 
             void ensure_no_live_buffers_bound() {}
 
=== modified file 'tests/integration-tests/test_surface_first_frame_sync.cpp'
--- tests/integration-tests/test_surface_first_frame_sync.cpp	2013-08-26 03:00:33 +0000
+++ tests/integration-tests/test_surface_first_frame_sync.cpp	2013-08-29 09:10:29 +0000
@@ -96,7 +96,7 @@
     {
     }
 
-    void clear() {}
+    void clear(unsigned long) override {}
 
     void render(std::function<void(std::shared_ptr<void> const&)>, mc::CompositingCriteria const&, ms::BufferStream&)
     {
 
=== modified file 'tests/integration-tests/test_swapinterval.cpp'
--- tests/integration-tests/test_swapinterval.cpp	2013-08-26 03:00:33 +0000
+++ tests/integration-tests/test_swapinterval.cpp	2013-08-29 09:10:29 +0000
@@ -57,7 +57,7 @@
     }
 
     std::shared_ptr<mg::Buffer> secure_client_buffer() { return std::make_shared<mtd::StubBuffer>(); }
-    std::shared_ptr<mg::Buffer> lock_compositor_buffer() { return std::make_shared<mtd::StubBuffer>(); }
+    std::shared_ptr<mg::Buffer> lock_compositor_buffer(unsigned long) { return std::make_shared<mtd::StubBuffer>(); }
     std::shared_ptr<mg::Buffer> lock_snapshot_buffer() { return std::make_shared<mtd::StubBuffer>(); }
     geom::PixelFormat get_stream_pixel_format() { return geom::PixelFormat::abgr_8888; }
     geom::Size stream_size() { return geom::Size{}; }
 
=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-08-27 10:19:54 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-08-29 09:10:29 +0000
@@ -200,10 +200,10 @@
                         mc::CompositingCriteria const&, ms::BufferStream& stream)
     {
         // Need to acquire the texture to cycle buffers
-        stream.lock_compositor_buffer();
+        stream.lock_compositor_buffer(0);
     }
 
-    void clear() {}
+    void clear(unsigned long) override {}
 };
 
 class StubRendererFactory : public mc::RendererFactory
 
=== modified file 'tests/unit-tests/compositor/test_buffer_stream.cpp'
--- tests/unit-tests/compositor/test_buffer_stream.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/compositor/test_buffer_stream.cpp	2013-08-29 09:10:29 +0000
@@ -95,7 +95,7 @@
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_bundle, compositor_acquire())
+    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
         .Times(1)
         .WillOnce(Return(mock_buffer));
     EXPECT_CALL(*mock_bundle, compositor_release(_))
@@ -103,14 +103,14 @@
 
     mc::BufferStreamSurfaces buffer_stream(mock_bundle);
 
-    buffer_stream.lock_compositor_buffer();
+    buffer_stream.lock_compositor_buffer(0);
 }
 
 TEST_F(BufferStreamTest, get_buffer_for_compositor_can_lock)
 {
     using namespace testing;
 
-    EXPECT_CALL(*mock_bundle, compositor_acquire())
+    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
         .Times(1)
         .WillOnce(Return(mock_buffer));
     EXPECT_CALL(*mock_bundle, compositor_release(_))
@@ -118,7 +118,7 @@
 
     mc::BufferStreamSurfaces buffer_stream(mock_bundle);
 
-    buffer_stream.lock_compositor_buffer();
+    buffer_stream.lock_compositor_buffer(0);
 }
 
 TEST_F(BufferStreamTest, get_buffer_for_client_releases_resources)
 
=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-08-26 03:00:33 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2013-08-29 09:10:29 +0000
@@ -97,7 +97,7 @@
     {
     }
 
-    void clear() { renderer->clear(); }
+    void clear(unsigned long f) override { renderer->clear(f); }
     void render(std::function<void(std::shared_ptr<void> const&)> save_resource,
                 mc::CompositingCriteria const& info, mir::surfaces::BufferStream& stream)
     {
@@ -254,7 +254,7 @@
     auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .WillOnce(Return(true));
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .WillOnce(Return(compositor_buffer));
 
     mc::DefaultDisplayBufferCompositorFactory factory(
@@ -303,7 +303,7 @@
     auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .Times(0);
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .Times(0);
 
     mc::DefaultDisplayBufferCompositorFactory factory(
@@ -352,7 +352,7 @@
     auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .Times(0);
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .Times(0);
 
     mc::DefaultDisplayBufferCompositorFactory factory(
@@ -399,7 +399,7 @@
     FakeScene scene(renderable_vec);
 
     auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .WillOnce(Return(compositor_buffer));
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .WillRepeatedly(Return(false));
@@ -450,7 +450,7 @@
     auto compositor_buffer = std::make_shared<mtd::MockBuffer>();
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .Times(0);
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .Times(0);
 
     mc::DefaultDisplayBufferCompositorFactory factory(
@@ -476,7 +476,7 @@
         .Times(0);
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
         .Times(0);
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .WillOnce(Return(compositor_buffer));
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .WillOnce(Return(true));
@@ -494,7 +494,7 @@
         .Times(1);
     EXPECT_CALL(renderer_factory.mock_renderer, render(_,Ref(fullscreen),_))
         .Times(0);
-    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer())
+    EXPECT_CALL(scene.stub_stream, lock_compositor_buffer(_))
         .Times(0);
     EXPECT_CALL(*compositor_buffer, can_bypass())
         .Times(0);
 
=== modified file 'tests/unit-tests/compositor/test_gl_renderer.cpp'
--- tests/unit-tests/compositor/test_gl_renderer.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/compositor/test_gl_renderer.cpp	2013-08-29 09:10:29 +0000
@@ -319,7 +319,7 @@
 
     EXPECT_CALL(mock_gl, glBindTexture(GL_TEXTURE_2D, stub_texture));
 
-    EXPECT_CALL(stream, lock_compositor_buffer())
+    EXPECT_CALL(stream, lock_compositor_buffer(_))
         .Times(1)
         .WillOnce(Return(mt::fake_shared(gr)));
     EXPECT_CALL(gr, bind_to_texture());
 
=== modified file 'tests/unit-tests/compositor/test_rendering_operator.cpp'
--- tests/unit-tests/compositor/test_rendering_operator.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/compositor/test_rendering_operator.cpp	2013-08-29 09:10:29 +0000
@@ -46,7 +46,7 @@
     {
     }
 
-    void clear() {}
+    void clear(unsigned long) override {}
 
     void render(std::function<void(std::shared_ptr<void> const&)> save_resource,
                 mc::CompositingCriteria const&, ms::BufferStream&)
 
=== modified file 'tests/unit-tests/compositor/test_switching_bundle.cpp'
--- tests/unit-tests/compositor/test_switching_bundle.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/compositor/test_switching_bundle.cpp	2013-08-29 09:10:29 +0000
@@ -102,19 +102,12 @@
 
 namespace
 {
-    const int frame_rate = 60;
-    const std::chrono::microseconds frame_time(1000000 / frame_rate);
-
-    void sleep_one_frame()
-    {
-        std::this_thread::sleep_for(frame_time);
-    }
-
     void composite_thread(mc::SwitchingBundle &bundle,
+                          unsigned long &frameno,
                           mg::BufferID &composited)
     {
-        sleep_one_frame();
-        auto buffer = bundle.compositor_acquire();
+        frameno++;
+        auto buffer = bundle.compositor_acquire(frameno);
         composited = buffer->id();
         bundle.compositor_release(buffer);
     }
@@ -126,6 +119,7 @@
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
         mg::BufferID prev_id, prev_prev_id;
+        unsigned long frameno = 0;
 
         ASSERT_FALSE(bundle.framedropping_allowed());
 
@@ -137,6 +131,7 @@
 
             std::thread compositor(composite_thread,
                                    std::ref(bundle),
+                                   std::ref(frameno),
                                    std::ref(composited_id));
 
             compositor.join();
@@ -148,7 +143,7 @@
             prev_prev_id = prev_id;
             prev_id = composited_id;
 
-            auto second_monitor = bundle.compositor_acquire();
+            auto second_monitor = bundle.compositor_acquire(frameno);
             ASSERT_EQ(composited_id, second_monitor->id());
             bundle.compositor_release(second_monitor);
         }
@@ -160,6 +155,7 @@
     for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned int frameno = 0;
 
         bundle.allow_framedropping(true);
         mg::BufferID last_client_id;
@@ -176,11 +172,12 @@
             // Flush the pipeline of previously ready buffers
             for (int k = 0; k < nbuffers-1; k++)
             {
-                bundle.compositor_release(bundle.compositor_acquire());
-                sleep_one_frame();
+                frameno++;
+                bundle.compositor_release(bundle.compositor_acquire(frameno));
             }
 
-            auto compositor = bundle.compositor_acquire();
+            frameno++;
+            auto compositor = bundle.compositor_acquire(frameno);
             ASSERT_EQ(last_client_id, compositor->id());
             bundle.compositor_release(compositor);
         }
@@ -200,7 +197,7 @@
     bundle.client_release(client2);
     client2.reset();
 
-    auto compositor = bundle.compositor_acquire();
+    auto compositor = bundle.compositor_acquire(1);
     EXPECT_EQ(client1_id, compositor->id());
     bundle.compositor_release(compositor);
 }
@@ -231,6 +228,7 @@
     for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 0;
 
         auto client = bundle.client_acquire();
         auto client_id = client->id();
@@ -238,7 +236,8 @@
 
         for (int monitor = 0; monitor < 10; monitor++)
         {
-            auto compositor = bundle.compositor_acquire();
+            frameno++;
+            auto compositor = bundle.compositor_acquire(frameno);
             ASSERT_EQ(client_id, compositor->id());
             bundle.compositor_release(compositor);
         }
@@ -250,13 +249,14 @@
     for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 0;
         const int N = 100;
 
         bundle.force_requests_to_complete();
 
         std::shared_ptr<mg::Buffer> buf[N];
         for (int i = 0; i < N; i++)
-            buf[i] = bundle.compositor_acquire();
+            buf[i] = bundle.compositor_acquire(++frameno);
 
         for (int i = 0; i < N; i++)
             bundle.compositor_release(buf[i]);
@@ -268,6 +268,7 @@
     for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 1;
 
         mg::BufferID client_id;
 
@@ -282,12 +283,12 @@
 
             for (int monitor_id = 0; monitor_id < 10; monitor_id++)
             {
-                auto compositor = bundle.compositor_acquire();
+                auto compositor = bundle.compositor_acquire(frameno);
                 ASSERT_EQ(client_id, compositor->id());
                 bundle.compositor_release(compositor);
             }
 
-            sleep_one_frame();
+            frameno++;
         }
     }
 }
@@ -297,6 +298,7 @@
     for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 0;
 
         auto client = bundle.client_acquire();
 
@@ -306,7 +308,7 @@
         );
         bundle.client_release(client);
 
-        auto compositor1 = bundle.compositor_acquire();
+        auto compositor1 = bundle.compositor_acquire(++frameno);
         bundle.compositor_release(compositor1);
         EXPECT_THROW(
             bundle.compositor_release(compositor1),
@@ -321,15 +323,16 @@
     for (int nbuffers = 2; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 1;
 
         std::shared_ptr<mg::Buffer> compositor[2];
 
         bundle.client_release(bundle.client_acquire());
-        compositor[0] = bundle.compositor_acquire();
+        compositor[0] = bundle.compositor_acquire(frameno);
 
-        sleep_one_frame();
+        frameno++;
         bundle.client_release(bundle.client_acquire());
-        compositor[1] = bundle.compositor_acquire();
+        compositor[1] = bundle.compositor_acquire(frameno);
 
         for (int i = 0; i < 20; i++)
         {
@@ -340,8 +343,8 @@
             int oldest = i & 1;
             bundle.compositor_release(compositor[oldest]);
             bundle.client_release(bundle.client_acquire());
-            sleep_one_frame();
-            compositor[oldest] = bundle.compositor_acquire();
+            frameno++;
+            compositor[oldest] = bundle.compositor_acquire(frameno);
         }
 
         bundle.compositor_release(compositor[0]);
@@ -355,7 +358,7 @@
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
 
-        auto compositor = bundle.compositor_acquire();
+        auto compositor = bundle.compositor_acquire(1);
         auto snapshot = bundle.snapshot_acquire();
         EXPECT_EQ(snapshot->id(), compositor->id());
         bundle.compositor_release(compositor);
@@ -385,7 +388,7 @@
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
 
-        auto compositor = bundle.compositor_acquire();
+        auto compositor = bundle.compositor_acquire(1);
 
         EXPECT_THROW(
             bundle.snapshot_release(compositor),
@@ -418,9 +421,10 @@
     void compositor_thread(mc::SwitchingBundle &bundle,
                            std::atomic<bool> &done)
     {
+        unsigned long frameno = 0;
         while (!done)
         {
-            bundle.compositor_release(bundle.compositor_acquire());
+            bundle.compositor_release(bundle.compositor_acquire(++frameno));
             std::this_thread::yield();
         }
     }
@@ -510,6 +514,7 @@
     for (int nbuffers = 1; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 0;
 
         bundle.allow_framedropping(false);
 
@@ -520,9 +525,9 @@
 
         for (int frame = 0; frame < nframes; frame++)
         {
-            sleep_one_frame();
+            frameno++;
 
-            auto compositor = bundle.compositor_acquire();
+            auto compositor = bundle.compositor_acquire(frameno);
             auto compositor_id = compositor->id();
             bundle.compositor_release(compositor);
 
@@ -542,15 +547,16 @@
     for (int nbuffers = 3; nbuffers <= 5; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long frameno = 1;
 
         std::shared_ptr<mg::Buffer> compositor[2];
 
         bundle.client_release(bundle.client_acquire());
-        compositor[0] = bundle.compositor_acquire();
+        compositor[0] = bundle.compositor_acquire(frameno);
 
-        sleep_one_frame();
+        frameno++;
         bundle.client_release(bundle.client_acquire());
-        compositor[1] = bundle.compositor_acquire();
+        compositor[1] = bundle.compositor_acquire(frameno);
 
         for (int i = 0; i < 20; i++)
         {
@@ -566,8 +572,8 @@
             int oldest = i & 1;
             bundle.compositor_release(compositor[oldest]);
 
-            sleep_one_frame();
-            compositor[oldest] = bundle.compositor_acquire();
+            frameno++;
+            compositor[oldest] = bundle.compositor_acquire(frameno);
         }
 
         bundle.compositor_release(compositor[0]);
@@ -649,85 +655,53 @@
 namespace
 {
     void realtime_compositor_thread(mc::SwitchingBundle &bundle,
+                                    unsigned long frames,
                                     std::atomic<bool> &done)
     {
-        while (!done)
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+
+        for (unsigned long frame = 0; frame < frames; frame++)
         {
-            auto buf = bundle.compositor_acquire();
-            sleep_one_frame();
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+            auto buf = bundle.compositor_acquire(frame);
             bundle.compositor_release(buf);
         }
+        done.store(true);
     }
 }
 
 TEST_F(SwitchingBundleTest, client_framerate_matches_compositor)
 {
-    const int expected =
-        std::chrono::duration_cast<std::chrono::microseconds>(frame_time)
-        .count();
-
-    int nframes = 0;
-    int nhiccups = 0;
-
     for (int nbuffers = 2; nbuffers <= 3; nbuffers++)
     {
         mc::SwitchingBundle bundle(nbuffers, allocator, basic_properties);
+        unsigned long client_frames = 0;
+        const unsigned long compose_frames = 20;
 
         bundle.allow_framedropping(false);
 
-        std::atomic<bool> done;
-        done = false;
+        std::atomic<bool> done(false);
 
         std::thread monitor1(realtime_compositor_thread,
-                             std::ref(bundle), std::ref(done));
-        std::thread monitor2(realtime_compositor_thread,
-                             std::ref(bundle), std::ref(done));
-        std::thread monitor3(realtime_compositor_thread,
-                             std::ref(bundle), std::ref(done));
-
-        for (int attempt = 0; attempt < 2; attempt++)
+                             std::ref(bundle),
+                             compose_frames,
+                             std::ref(done));
+
+        bundle.client_release(bundle.client_acquire());
+
+        while (!done.load())
         {
-            // Initial queue filling is not throttled...
-            for (int f = 0; f < nbuffers + 1; f++)
-                bundle.client_release(bundle.client_acquire());
-
-            auto prev = std::chrono::high_resolution_clock::now();
-
-            for (int second = 0; second < 2; second++)
-            {
-                for (int frame = 0; frame < frame_rate; frame++)
-                {
-                    bundle.client_release(bundle.client_acquire());
-
-                    auto t = std::chrono::high_resolution_clock::now();
-                    auto d = t - prev;
-                    prev = t;
-
-                    int measured_frame_time_usec =
-                        std::chrono::duration_cast<std::chrono::microseconds>(d)
-                        .count();
-
-                    nframes++;
-                    if (expected * 0.7f > measured_frame_time_usec ||
-                        expected * 1.3f < measured_frame_time_usec)
-                    {
-                        nhiccups++;
-                    }
-                }
-            }
-
-            // Simulate a pause/resume like VT switching
-            bundle.force_requests_to_complete();
+            bundle.client_release(bundle.client_acquire());
+            client_frames++;
+            std::this_thread::yield();
         }
 
-        done = true;
-
         monitor1.join();
-        monitor2.join();
-        monitor3.join();
 
-        int hiccups_percent = nhiccups * 100 / nframes;
-        ASSERT_LT(hiccups_percent, 10);
+        // Roughly compose_frames == client_frames within 50%
+        ASSERT_GT(client_frames, compose_frames / 2);
+        ASSERT_LT(client_frames, compose_frames * 3 / 2);
     }
 }
 
 
=== modified file 'tests/unit-tests/compositor/test_temporary_buffers.cpp'
--- tests/unit-tests/compositor/test_temporary_buffers.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/compositor/test_temporary_buffers.cpp	2013-08-29 09:10:29 +0000
@@ -54,7 +54,7 @@
 
         ON_CALL(*mock_bundle, client_acquire())
             .WillByDefault(Return(mock_buffer));
-        ON_CALL(*mock_bundle, compositor_acquire())
+        ON_CALL(*mock_bundle, compositor_acquire(_))
             .WillByDefault(Return(mock_buffer));
     }
 
@@ -92,12 +92,12 @@
 TEST_F(TemporaryBuffersTest, compositor_buffer_acquires_and_releases)
 {
     using namespace testing;
-    EXPECT_CALL(*mock_bundle, compositor_acquire())
+    EXPECT_CALL(*mock_bundle, compositor_acquire(_))
         .WillOnce(Return(mock_buffer));
     EXPECT_CALL(*mock_bundle, compositor_release(_))
         .Times(1);
 
-    mc::TemporaryCompositorBuffer proxy_buffer(mock_bundle);
+    mc::TemporaryCompositorBuffer proxy_buffer(mock_bundle, 0);
 }
 
 TEST_F(TemporaryBuffersTest, snapshot_buffer_acquires_and_releases)
 
=== modified file 'tests/unit-tests/surfaces/test_surface.cpp'
--- tests/unit-tests/surfaces/test_surface.cpp	2013-08-09 01:37:53 +0000
+++ tests/unit-tests/surfaces/test_surface.cpp	2013-08-29 09:10:29 +0000
@@ -308,7 +308,7 @@
     ms::Surface surf(mock_basic_state, mock_buffer_stream, std::shared_ptr<mi::InputChannel>());
     auto buffer_resource = std::make_shared<mtd::StubBuffer>();
 
-    EXPECT_CALL(*mock_buffer_stream, lock_compositor_buffer())
+    EXPECT_CALL(*mock_buffer_stream, lock_compositor_buffer(_))
         .Times(AtLeast(1))
         .WillOnce(Return(buffer_resource));
 
 
=== modified file 'tests/unit-tests/surfaces/test_surface_stack.cpp'
--- tests/unit-tests/surfaces/test_surface_stack.cpp	2013-08-26 03:00:33 +0000
+++ tests/unit-tests/surfaces/test_surface_stack.cpp	2013-08-29 09:10:29 +0000
@@ -69,7 +69,8 @@
 public:
     virtual std::shared_ptr<mg::Buffer> client_acquire() { return std::shared_ptr<mg::Buffer>(); }
     virtual void client_release(std::shared_ptr<mg::Buffer> const&) {}
-    virtual std::shared_ptr<mg::Buffer> compositor_acquire(){ return std::shared_ptr<mg::Buffer>(); };
+    virtual std::shared_ptr<mg::Buffer> compositor_acquire(unsigned long)
+        { return std::shared_ptr<mg::Buffer>(); };
     virtual void compositor_release(std::shared_ptr<mg::Buffer> const&){}
     virtual std::shared_ptr<mg::Buffer> snapshot_acquire(){ return std::shared_ptr<mg::Buffer>(); };
     virtual void snapshot_release(std::shared_ptr<mg::Buffer> const&){}