Merge lp:~vanvugt/mir/swap-then-flip into lp:mir

[Daniel van Vugt]

Split post_update() into separate gl_swap_buffers() and flip().

On some platforms this provides a significant performance boost, as
GL resources and client buffers can be released after the gl_swap_buffers
without having to wait for the flip.

This solves most of LP: #1264934, and unblocks work on LP: #1350716 and
possibly unblocks LP: #1350725 too.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2172
http://jenkins.qa.ubuntu.com/job/mir-ci/2495/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/619
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/619
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/593
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/492
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/492/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/593
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/593/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3744
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16698

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Mostly good. But surely:

456 - void post_update() override
457 + void gl_swap_buffers() override
458 + {
459 + increment_post_count();
460 + }
461 +
462 + void flip() override
463 {
464 increment_post_count();
465 }

"post_count" is now a misnomer and also is incremented by two calls where it would have been incremented once before.

review: Needs Fixing

[Cemil Azizoglu (cemil-azizoglu)]

egl_swap_buffers (i.e. the driver) is supposed to flip the buffer to the screen. I don't understand why we have to do this manually on Mesa? Besides, when swap_buffers returns, GPU is still rendering into the (now front) buffer. If we flip prematurely, it'll tear. The only way to guarantee no tearing is if the swapbuffers implementation flips the buffer itself once rendering is completed.

Other nits :
57 + * an unacceptable performance hit to wait for both before before freeing
duplicate "before"

137 - mir::graphics::DisplayBuffer::post_update*;
Shouldn't we be adding "gl_swap_buffers" and "flip" to symbols.map?

review: Needs Information

[Robert Carr (robertcarr)]

Cemils comment was discussed in IRC. I believe the driver handles this synchronization.

I'm not so sure if this is a real optimization, e.g. the expensive part of swap is the flush and presumably rendering was already happening in the background anyway. I agree this seems conceptually correct though: Finish GL Rendering, Update EGL State, Mark buffer as new front buffer.

Please get review from someone with better knowledge of this than me, e.g. Alf, Chris, ...?

review: Approve

[Daniel van Vugt (vanvugt)]

I understand your confusion and I started off believing the same thing too. As an OpenGL person you come to expect *glSwapBuffers to do all the work, but that's not true on the DRM platform (or reasonably any other low-level platform). Because there's no display server in the Mesa library. We're providing the display server. eglSwapBuffers in Mesa/DRM puts nothing on screen; it doesn't know how. All it does is prepare the next front-buffer for gbm_surface_lock_front_buffer to acquire and then it's up to the display server (us) to scan it out by page flipping or otherwise.

Furthermore, eglSwapBuffers does not implement any synchronization on Mesa-DRM either. It is up to us to sync to vblank in how we schedule the page flips. And how would Mesa-DRM have any idea what monitors you wanted to display on? That's up to us in what outputs/connectors we choose to page flip to.

Other nits:
"before before": Fixed and will land here soon.
"symbols.map": Apparently not. Everything works without mentioning it in symbols.map...(?)

P.S. The performance benefits won't be fully realized until we start unwinding the triple buffering a bit more (LP: #1350725).

P.P.S. Some real numbers from my own system (following lp:~vanvugt/mir/fix-1350716), is that this change reduces the time the compositor holds buffers from around ~15ms to ~0.4ms. Still it only consumes a new client buffer every 16.6ms.

[Daniel van Vugt (vanvugt)]

Hmm, I've been thinking it might help to reduce confusion with a better name than "flip". Perhaps hw_swap_buffers() would be better...

   gl_swap_buffers()
   hw_swap_buffers()

[Daniel van Vugt (vanvugt)]

I also plan to clarify things further by separating the generic DisplayBuffer from the (GL-specific)DisplayBuffer we use today. This will make it more clear that Mir is not strictly tied to OpenGL and that OpenGL still needs additional display logic underneath it to put anything on screen.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2177
http://jenkins.qa.ubuntu.com/job/mir-ci/2516/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/647
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/647
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/621
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/513
        deb: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/513/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/621
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/621/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3768
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16732

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

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

To further address the "flip" concerns:

 * Page flipping can never tear unless you accidentally steal a buffer that's presently scanning out, which we don't do. And that's why we've been using page flipping forever in Mir, and since 2012 in Compiz. To page flip means you reprogram the display hardware to scan out a different region of memory during vblank. There is no copying or blitting involved that can ever be seen as tearing.

 * wait_for_page_flip() waits only for the schedule_page_flip() of the _previous_ call to flip (the previous frame) and so has no relationship to the EGL swapping work going on in the current frame. It's asynchronous and effectively triple buffered so as to support clone mode (multiple vsync signals permanently out of phase). I know it's very confusing. I've spent many days of my life improving the little flip/post_update() function to make it as fast and reliable as it is.

[Alan Griffiths (alan-griffiths)]

OK

review: Approve

[Cemil Azizoglu (cemil-azizoglu)]

I still have doubts, but not about your MP, about the way Mesa works.

review: Approve

[Alberto Aguirre (albaguirre)]

Looks sensible.

review: Approve

=== modified file 'benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp'
--- benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2014-12-16 18:35:06 +0000
+++ benchmarks/frame-uniformity/vsync_simulating_graphics_platform.cpp	2014-12-19 03:08:20 +0000
@@ -45,7 +45,11 @@
     {
     }
     
-    void post_update() override
+    void gl_swap_buffers() override
+    {
+    }
+
+    void flip() override
     {
         auto now = std::chrono::high_resolution_clock::now();
         auto next_sync = last_sync + std::chrono::seconds(1) / vsync_rate_in_hz;

=== modified file 'examples/render_to_fb.cpp'
--- examples/render_to_fb.cpp	2014-11-14 02:41:05 +0000
+++ examples/render_to_fb.cpp	2014-12-19 03:08:20 +0000
@@ -67,7 +67,8 @@
 
             gl_animation.render_gl();
 
-            buffer.post_update();
+            buffer.gl_swap_buffers();
+            buffer.flip();
         });
 
         gl_animation.step();

=== modified file 'include/platform/mir/graphics/display_buffer.h'
--- include/platform/mir/graphics/display_buffer.h	2014-12-08 04:03:47 +0000
+++ include/platform/mir/graphics/display_buffer.h	2014-12-19 03:08:20 +0000
@@ -47,8 +47,33 @@
     /** Releases the current GL rendering target. */
     virtual void release_current() = 0;
 
-    /** This will trigger OpenGL rendering and post the result to the screen. */
-    virtual void post_update() = 0;
+    /**
+     * Swap buffers for OpenGL rendering.
+     * After this method returns is the earliest time that it is safe to
+     * free GL-related resources such as textures and buffers.
+     */
+    virtual void gl_swap_buffers() = 0;
+
+    /**
+     * After gl_swap_buffers, flip the new front buffer to the screen
+     * This most likely involves a wait for vblank so can be very time
+     * consuming. This function is separate to gl_swap_buffers() because in
+     * real display systems the act of scanning out (or flipping) the
+     * front buffer is a very separate step to the GL buffer swapping. Not
+     * least because "flipping" is a hardware operation that is independent
+     * of the graphics library (OpenGL or other). Also, flip() can be a
+     * dramatically slower operation than gl_swap_buffers() and it would be
+     * an unacceptable performance hit to wait for both before freeing
+     * GL resources.
+     */
+    virtual void flip() = 0;
+
+    /**
+     * \deprecated Please try to implement separate gl_swap_buffers and
+     * flip functions instead. If not possible, just move your old
+     * post_update() logic into gl_swap_buffers.
+     */
+    void post_update() { gl_swap_buffers(); flip(); }
 
     /** This will render renderlist to the screen and post the result to the 
      *  screen if there is a hardware optimization that can be done.

=== modified file 'platform-ABI-sha1sums'
--- platform-ABI-sha1sums	2014-12-19 01:56:10 +0000
+++ platform-ABI-sha1sums	2014-12-19 03:08:20 +0000
@@ -33,7 +33,7 @@
 748f5c2aab11189aa02c4a89ab900561548e7304  include/platform/mir/graphics/buffer_properties.h
 ffa857f624f1c8cbd50a190107137346fc3204d6  include/platform/mir/graphics/cursor.h
 fe2b5f13ccd3ec6b78d90d3abbb7d88b48238578  include/platform/mir/graphics/cursor_image.h
-986f5d0d8ea2c6a42cc320f468e682f81fec46ae  include/platform/mir/graphics/display_buffer.h
+0025a5c3e9d916820f3ef27aee9f5d4a9985723b  include/platform/mir/graphics/display_buffer.h
 f53a0020b8f1bd4a941a201eb26271cffee0a7dd  include/platform/mir/graphics/display_configuration.h
 6fe08da318c920b0d20ea8b8f560f5ac7ed389fe  include/platform/mir/graphics/display_configuration_policy.h
 41ea906d208b761e3d5d5056095de9de2d4ffa17  include/platform/mir/graphics/display.h

=== modified file 'playground/demo-shell/demo_compositor.cpp'
--- playground/demo-shell/demo_compositor.cpp	2014-12-08 04:03:47 +0000
+++ playground/demo-shell/demo_compositor.cpp	2014-12-19 03:08:20 +0000
@@ -118,6 +118,7 @@
      *       Actually, there's a third reference held by the texture cache
      *       in GLRenderer, but that gets released earlier in render().
      */
+    elements.clear();  // Release those that didn't make it to renderable_list
 
     if (!nonrenderlist_elements &&
         viewport == display_buffer.view_area() &&  // no bypass while zoomed
@@ -134,7 +135,18 @@
         renderer.set_viewport(viewport);
         renderer.begin(std::move(decoration_skip_list));
         renderer.render(renderable_list);
-        display_buffer.post_update();
+
+        display_buffer.gl_swap_buffers();
+        // TODO: report->record_end_of_render_time here. (LP: #1350716)
+
+        // Release buffers back to the clients now that the swap has returned.
+        // It's important to do this before starting on the potentially slow
+        // flip() ...
+        // FIXME: This clear() call is blocking a little (LP: #1395421)
+        renderable_list.clear();
+
+        display_buffer.flip();
+
         report->finished_frame(false, this);
     }
 }

=== modified file 'server-ABI-sha1sums'
--- server-ABI-sha1sums	2014-12-19 01:56:10 +0000
+++ server-ABI-sha1sums	2014-12-19 03:08:20 +0000
@@ -33,7 +33,7 @@
 748f5c2aab11189aa02c4a89ab900561548e7304  include/platform/mir/graphics/buffer_properties.h
 ffa857f624f1c8cbd50a190107137346fc3204d6  include/platform/mir/graphics/cursor.h
 fe2b5f13ccd3ec6b78d90d3abbb7d88b48238578  include/platform/mir/graphics/cursor_image.h
-986f5d0d8ea2c6a42cc320f468e682f81fec46ae  include/platform/mir/graphics/display_buffer.h
+0025a5c3e9d916820f3ef27aee9f5d4a9985723b  include/platform/mir/graphics/display_buffer.h
 f53a0020b8f1bd4a941a201eb26271cffee0a7dd  include/platform/mir/graphics/display_configuration.h
 6fe08da318c920b0d20ea8b8f560f5ac7ed389fe  include/platform/mir/graphics/display_configuration_policy.h
 41ea906d208b761e3d5d5056095de9de2d4ffa17  include/platform/mir/graphics/display.h

=== modified file 'src/platform/symbols.map'
--- src/platform/symbols.map	2014-12-16 18:35:06 +0000
+++ src/platform/symbols.map	2014-12-19 03:08:20 +0000
@@ -36,7 +36,6 @@
     mir::graphics::DisplayBuffer::operator*;
     mir::graphics::DisplayBuffer::orientation*;
     mir::graphics::DisplayBuffer::post_renderables_if_optimizable*;
-    mir::graphics::DisplayBuffer::post_update*;
     mir::graphics::DisplayBuffer::release_current*;
     mir::graphics::DisplayBuffer::uses_alpha*;
     mir::graphics::DisplayBuffer::view_area*;

=== modified file 'src/platforms/android/display_buffer.cpp'
--- src/platforms/android/display_buffer.cpp	2014-12-18 03:10:03 +0000
+++ src/platforms/android/display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -96,11 +96,15 @@
     return display_device->post_overlays(gl_context, renderlist, overlay_program);
 }
 
-void mga::DisplayBuffer::post_update()
+void mga::DisplayBuffer::gl_swap_buffers()
 {
     display_device->post_gl(gl_context);
 }
 
+void mga::DisplayBuffer::flip()
+{
+}
+
 MirOrientation mga::DisplayBuffer::orientation() const
 {
     /*

=== modified file 'src/platforms/android/display_buffer.h'
--- src/platforms/android/display_buffer.h	2014-12-08 04:03:47 +0000
+++ src/platforms/android/display_buffer.h	2014-12-19 03:08:20 +0000
@@ -51,7 +51,8 @@
     geometry::Rectangle view_area() const override;
     void make_current() override;
     void release_current() override;
-    void post_update() override;
+    void gl_swap_buffers() override;
+    void flip() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
 
     MirOrientation orientation() const override;

=== modified file 'src/platforms/mesa/display_buffer.cpp'
--- src/platforms/mesa/display_buffer.cpp	2014-12-19 00:35:16 +0000
+++ src/platforms/mesa/display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -202,7 +202,7 @@
             if (bypass_buf->can_bypass() &&
                 bypass_buf->size() == geom::Size{fb_width,fb_height})
             {
-                return post_update(bypass_buf);
+                return flip(bypass_buf);
             }
         }
     }
@@ -210,26 +210,21 @@
     return false;
 }
 
-void mgm::DisplayBuffer::post_update()
-{
-    post_update(nullptr);
-}
-
-bool mgm::DisplayBuffer::post_update(
+void mgm::DisplayBuffer::flip()
+{
+    flip(nullptr);
+}
+
+void mgm::DisplayBuffer::gl_swap_buffers()
+{
+    if (!egl.swap_buffers())
+        fatal_error("Failed to perform buffer swap");
+}
+
+bool mgm::DisplayBuffer::flip(
     std::shared_ptr<graphics::Buffer> bypass_buf)
 {
     /*
-     * There are two potentially blocking operations in this function:
-     *  1. egl.swap_buffers()
-     *  2. wait_for_page_flip()
-     * However only the first one has a chance of being implemented by the
-     * driver asynchronously (so it returns before it's finished) as observed
-     * with Intel graphics. So for optimal parallelism EGL swap starts first.
-     */
-    if (!bypass_buf && !egl.swap_buffers())
-        fatal_error("Failed to perform buffer swap");
-
-    /*
      * We might not have waited for the previous frame to page flip yet.
      * This is good because it maximizes the time available to spend rendering
      * each frame. Just remember wait_for_page_flip() must be called at some

=== modified file 'src/platforms/mesa/display_buffer.h'
--- src/platforms/mesa/display_buffer.h	2014-12-18 03:10:03 +0000
+++ src/platforms/mesa/display_buffer.h	2014-12-19 03:08:20 +0000
@@ -57,7 +57,8 @@
     geometry::Rectangle view_area() const override;
     void make_current() override;
     void release_current() override;
-    void post_update() override;
+    void gl_swap_buffers() override;
+    void flip() override;
     bool post_renderables_if_optimizable(RenderableList const& renderlist) override;
 
     MirOrientation orientation() const override;
@@ -66,7 +67,7 @@
     void wait_for_page_flip();
 
 private:
-    bool post_update(std::shared_ptr<graphics::Buffer> bypass_buf);
+    bool flip(std::shared_ptr<graphics::Buffer> bypass_buf);
 
     BufferObject* get_front_buffer_object();
     BufferObject* get_buffer_object(struct gbm_bo *bo);

=== modified file 'src/server/compositor/default_display_buffer_compositor.cpp'
--- src/server/compositor/default_display_buffer_compositor.cpp	2014-12-08 04:03:47 +0000
+++ src/server/compositor/default_display_buffer_compositor.cpp	2014-12-19 03:08:20 +0000
@@ -72,6 +72,7 @@
      *       Actually, there's a third reference held by the texture cache
      *       in GLRenderer, but that gets released earlier in render().
      */
+    scene_elements.clear();  // Those in use are still in renderable_list
 
     if (display_buffer.post_renderables_if_optimizable(renderable_list))
     {
@@ -85,7 +86,17 @@
         renderer->set_rotation(display_buffer.orientation());
 
         renderer->render(renderable_list);
-        display_buffer.post_update();
+
+        display_buffer.gl_swap_buffers();
+
+        // TODO: report->record_end_of_render_time here. (LP: #1350716)
+
+        // Release the buffers we did use back to the clients, before starting
+        // on the potentially slow flip().
+        // FIXME: This clear() call is blocking a little (LP: #1395421)
+        renderable_list.clear();
+
+        display_buffer.flip();
 
         report->finished_frame(false, this);
     }

=== modified file 'src/server/compositor/screencast_display_buffer.cpp'
--- src/server/compositor/screencast_display_buffer.cpp	2014-12-08 04:03:47 +0000
+++ src/server/compositor/screencast_display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -90,11 +90,15 @@
     return false;
 }
 
-void mc::ScreencastDisplayBuffer::post_update()
+void mc::ScreencastDisplayBuffer::gl_swap_buffers()
 {
     glFinish();
 }
 
+void mc::ScreencastDisplayBuffer::flip()
+{
+}
+
 MirOrientation mc::ScreencastDisplayBuffer::orientation() const
 {
     return mir_orientation_normal;

=== modified file 'src/server/compositor/screencast_display_buffer.h'
--- src/server/compositor/screencast_display_buffer.h	2014-12-08 04:03:47 +0000
+++ src/server/compositor/screencast_display_buffer.h	2014-12-19 03:08:20 +0000
@@ -61,7 +61,8 @@
 
     bool post_renderables_if_optimizable(graphics::RenderableList const&) override;
 
-    void post_update() override;
+    void gl_swap_buffers() override;
+    void flip() override;
 
     MirOrientation orientation() const override;
 

=== modified file 'src/server/graphics/nested/nested_output.cpp'
--- src/server/graphics/nested/nested_output.cpp	2014-12-08 04:03:47 +0000
+++ src/server/graphics/nested/nested_output.cpp	2014-12-19 03:08:20 +0000
@@ -63,11 +63,15 @@
     eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
-void mgn::detail::NestedOutput::post_update()
+void mgn::detail::NestedOutput::gl_swap_buffers()
 {
     eglSwapBuffers(egl_display, egl_surface);
 }
 
+void mgn::detail::NestedOutput::flip()
+{
+}
+
 bool mgn::detail::NestedOutput::post_renderables_if_optimizable(RenderableList const&)
 {
     return false;

=== modified file 'src/server/graphics/nested/nested_output.h'
--- src/server/graphics/nested/nested_output.h	2014-12-08 04:03:47 +0000
+++ src/server/graphics/nested/nested_output.h	2014-12-19 03:08:20 +0000
@@ -47,7 +47,8 @@
     geometry::Rectangle view_area() const override;
     void make_current() override;
     void release_current() override;
-    void post_update() override;
+    void gl_swap_buffers() override;
+    void flip() override;
     MirOrientation orientation() const override;
     bool uses_alpha() const override;
 

=== modified file 'src/server/graphics/offscreen/display_buffer.cpp'
--- src/server/graphics/offscreen/display_buffer.cpp	2014-12-08 04:03:47 +0000
+++ src/server/graphics/offscreen/display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -139,11 +139,15 @@
     egl_context.release_current();
 }
 
-void mgo::DisplayBuffer::post_update()
+void mgo::DisplayBuffer::gl_swap_buffers()
 {
     glFinish();
 }
 
+void mgo::DisplayBuffer::flip()
+{
+}
+
 bool mgo::DisplayBuffer::post_renderables_if_optimizable(RenderableList const&)
 {
     return false;

=== modified file 'src/server/graphics/offscreen/display_buffer.h'
--- src/server/graphics/offscreen/display_buffer.h	2014-12-08 04:03:47 +0000
+++ src/server/graphics/offscreen/display_buffer.h	2014-12-19 03:08:20 +0000
@@ -65,7 +65,8 @@
     geometry::Rectangle view_area() const override;
     void make_current() override;
     void release_current() override;
-    void post_update() override;
+    void gl_swap_buffers() override;
+    void flip() override;
 
     MirOrientation orientation() const override;
     bool uses_alpha() const override;

=== modified file 'tests/include/mir_test_doubles/mock_display_buffer.h'
--- tests/include/mir_test_doubles/mock_display_buffer.h	2014-12-08 04:03:47 +0000
+++ tests/include/mir_test_doubles/mock_display_buffer.h	2014-12-19 03:08:20 +0000
@@ -42,7 +42,8 @@
     MOCK_CONST_METHOD0(view_area, geometry::Rectangle());
     MOCK_METHOD0(make_current, void());
     MOCK_METHOD0(release_current, void());
-    MOCK_METHOD0(post_update, void());
+    MOCK_METHOD0(gl_swap_buffers, void());
+    MOCK_METHOD0(flip, void());
     MOCK_METHOD1(post_renderables_if_optimizable, bool(graphics::RenderableList const&));
     MOCK_CONST_METHOD0(orientation, MirOrientation());
     MOCK_CONST_METHOD0(uses_alpha, bool());

=== modified file 'tests/include/mir_test_doubles/null_display_buffer.h'
--- tests/include/mir_test_doubles/null_display_buffer.h	2014-12-08 04:03:47 +0000
+++ tests/include/mir_test_doubles/null_display_buffer.h	2014-12-19 03:08:20 +0000
@@ -34,7 +34,8 @@
     geometry::Rectangle view_area() const override { return geometry::Rectangle(); }
     void make_current() override {}
     void release_current() override {}
-    void post_update() override {}
+    void gl_swap_buffers() override {}
+    void flip() override {}
     bool post_renderables_if_optimizable(graphics::RenderableList const&) override { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
     bool uses_alpha() const override { return false; }

=== modified file 'tests/include/mir_test_doubles/stub_display_builder.h'
--- tests/include/mir_test_doubles/stub_display_builder.h	2014-12-17 06:58:58 +0000
+++ tests/include/mir_test_doubles/stub_display_builder.h	2014-12-19 03:08:20 +0000
@@ -40,7 +40,8 @@
     geometry::Rectangle view_area() const { return rect; }
     void make_current() {}
     void release_current() {}
-    void post_update() {}
+    void gl_swap_buffers() {}
+    void flip() {}
     bool post_renderables_if_optimizable(graphics::RenderableList const&) { return false; }
     MirOrientation orientation() const override { return mir_orientation_normal; }
     bool uses_alpha() const override { return false; };

=== modified file 'tests/integration-tests/graphics/android/test_display_integration.cpp'
--- tests/integration-tests/graphics/android/test_display_integration.cpp	2014-12-17 06:58:58 +0000
+++ tests/integration-tests/graphics/android/test_display_integration.cpp	2014-12-19 03:08:20 +0000
@@ -88,10 +88,12 @@
         gl_animation.init_gl();
 
         gl_animation.render_gl();
-        buffer.post_update();
+        buffer.gl_swap_buffers();
+        buffer.flip();
 
         gl_animation.render_gl();
-        buffer.post_update();
+        buffer.gl_swap_buffers();
+        buffer.flip();
     });
 }
 

=== modified file 'tests/integration-tests/test_surface_stack_with_compositor.cpp'
--- tests/integration-tests/test_surface_stack_with_compositor.cpp	2014-12-08 04:03:47 +0000
+++ tests/integration-tests/test_surface_stack_with_compositor.cpp	2014-12-19 03:08:20 +0000
@@ -69,7 +69,11 @@
         return false;
     }
 
-    void post_update() override
+    void gl_swap_buffers() override
+    {
+    }
+
+    void flip() override
     {
         increment_post_count();
     }

=== modified file 'tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp'
--- tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2014-12-08 04:03:47 +0000
+++ tests/unit-tests/compositor/test_default_display_buffer_compositor.cpp	2014-12-19 03:08:20 +0000
@@ -122,7 +122,9 @@
         .Times(AtLeast(1));
     EXPECT_CALL(display_buffer, make_current())
         .Times(1);
-    EXPECT_CALL(display_buffer, post_update())
+    EXPECT_CALL(display_buffer, gl_swap_buffers())
+        .Times(1);
+    EXPECT_CALL(display_buffer, flip())
         .Times(1);
 
     mc::DefaultDisplayBufferCompositor compositor(
@@ -229,7 +231,9 @@
         .InSequence(render_seq);
     EXPECT_CALL(mock_renderer, render(ContainerEq(mg::RenderableList{big, small})))
         .InSequence(render_seq);
-    EXPECT_CALL(display_buffer, post_update())
+    EXPECT_CALL(display_buffer, gl_swap_buffers())
+        .InSequence(render_seq);
+    EXPECT_CALL(display_buffer, flip())
         .InSequence(render_seq);
 
     mc::DefaultDisplayBufferCompositor compositor(
@@ -264,7 +268,9 @@
         .InSequence(seq);
     EXPECT_CALL(mock_renderer, render(IsEmpty()))
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, post_update())
+    EXPECT_CALL(display_buffer, gl_swap_buffers())
+        .InSequence(seq);
+    EXPECT_CALL(display_buffer, flip())
         .InSequence(seq);
 
     EXPECT_CALL(display_buffer, post_renderables_if_optimizable(_))
@@ -283,7 +289,9 @@
         .InSequence(seq);
     EXPECT_CALL(mock_renderer, render(IsEmpty()))
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, post_update())
+    EXPECT_CALL(display_buffer, gl_swap_buffers())
+        .InSequence(seq);
+    EXPECT_CALL(display_buffer, flip())
         .InSequence(seq);
 
     mc::DefaultDisplayBufferCompositor compositor(
@@ -321,7 +329,9 @@
         .InSequence(seq);
     EXPECT_CALL(mock_renderer, render(ContainerEq(visible)))
         .InSequence(seq);
-    EXPECT_CALL(display_buffer, post_update())
+    EXPECT_CALL(display_buffer, gl_swap_buffers())
+        .InSequence(seq);
+    EXPECT_CALL(display_buffer, flip())
         .InSequence(seq);
 
     mc::DefaultDisplayBufferCompositor compositor(

=== modified file 'tests/unit-tests/compositor/test_screencast_display_buffer.cpp'
--- tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2014-12-08 04:03:47 +0000
+++ tests/unit-tests/compositor/test_screencast_display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -133,7 +133,7 @@
     db.make_current();
 }
 
-TEST_F(ScreencastDisplayBufferTest, forces_rendering_to_complete_on_post_update)
+TEST_F(ScreencastDisplayBufferTest, forces_rendering_to_complete_on_swap)
 {
     using namespace testing;
 
@@ -145,7 +145,7 @@
     Mock::VerifyAndClearExpectations(&mock_gl);
     EXPECT_CALL(mock_gl, glFinish());
 
-    db.post_update();
+    db.gl_swap_buffers();
 }
 
 TEST_F(ScreencastDisplayBufferTest, rejects_attempt_to_optimize)

=== modified file 'tests/unit-tests/graphics/android/test_display_buffer.cpp'
--- tests/unit-tests/graphics/android/test_display_buffer.cpp	2014-12-18 03:10:03 +0000
+++ tests/unit-tests/graphics/android/test_display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -99,7 +99,8 @@
     mg::RenderableList renderlist{};
     mga::DisplayBuffer db(
         mock_fb_bundle, mock_display_device, native_window, *gl_context, stub_program_factory, mga::OverlayOptimization::enabled);
-    db.post_update();
+    db.gl_swap_buffers();
+    db.flip();
 }
 
 TEST_F(DisplayBuffer, posts_overlay_list_returns_display_device_decision)

=== modified file 'tests/unit-tests/graphics/mesa/test_display.cpp'
--- tests/unit-tests/graphics/mesa/test_display.cpp	2014-12-17 06:58:58 +0000
+++ tests/unit-tests/graphics/mesa/test_display.cpp	2014-12-19 03:08:20 +0000
@@ -439,7 +439,8 @@
 
     display->for_each_display_buffer([](mg::DisplayBuffer& db)
     {
-        db.post_update();
+        db.gl_swap_buffers();
+        db.flip();
     });
 }
 
@@ -477,7 +478,8 @@
 
         display->for_each_display_buffer([](mg::DisplayBuffer& db)
         {
-            db.post_update();
+            db.gl_swap_buffers();
+            db.flip();
         });
     }, std::runtime_error);
 }

=== modified file 'tests/unit-tests/graphics/mesa/test_display_buffer.cpp'
--- tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2014-12-19 00:35:16 +0000
+++ tests/unit-tests/graphics/mesa/test_display_buffer.cpp	2014-12-19 03:08:20 +0000
@@ -294,7 +294,7 @@
         mock_egl.fake_egl_context);
 }
 
-TEST_F(MesaDisplayBufferTest, first_post_flips_but_no_wait)
+TEST_F(MesaDisplayBufferTest, first_flip_flips_but_no_wait)
 {
     EXPECT_CALL(*mock_kms_output, schedule_page_flip(_))
         .Times(1);
@@ -311,10 +311,11 @@
         gl_config,
         mock_egl.fake_egl_context);
 
-    db.post_update();
+    db.gl_swap_buffers();
+    db.flip();
 }
 
-TEST_F(MesaDisplayBufferTest, waits_for_page_flip_on_second_post)
+TEST_F(MesaDisplayBufferTest, waits_for_page_flip_on_second_flip)
 {
     InSequence seq;
 
@@ -339,8 +340,11 @@
         gl_config,
         mock_egl.fake_egl_context);
 
-    db.post_update();
-    db.post_update();
+    db.gl_swap_buffers();
+    db.flip();
+
+    db.gl_swap_buffers();
+    db.flip();
 }
 
 TEST_F(MesaDisplayBufferTest, skips_bypass_because_of_incompatible_list)

=== modified file 'tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp'
--- tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2014-12-16 09:26:49 +0000
+++ tests/unit-tests/graphics/mesa/test_display_multi_monitor.cpp	2014-12-19 03:08:20 +0000
@@ -315,7 +315,7 @@
 
 }
 
-TEST_F(MesaDisplayMultiMonitorTest, post_update_flips_all_connected_crtcs)
+TEST_F(MesaDisplayMultiMonitorTest, flip_flips_all_connected_crtcs)
 {
     using namespace testing;
 
@@ -356,14 +356,16 @@
     /* First frame: Page flips are scheduled, but not waited for */
     display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
     {
-        buffer.post_update();
+        buffer.gl_swap_buffers();
+        buffer.flip();
     });
 
     /* Second frame: Previous page flips finish (drmHandleEvent) and new ones
        are scheduled */
     display->for_each_display_buffer([](mg::DisplayBuffer& buffer)
     {
-        buffer.post_update();
+        buffer.gl_swap_buffers();
+        buffer.flip();
     });
 }