Merge lp:~vanvugt/mir/better-scaling-test into lp:mir

[Daniel van Vugt]

Rewrite unit test: queue_size_scales_with_client_performance
so that it is not dependent on real time and threads racing
each other.

The robustness of this test was an issue for later related work.
It started failing spuriously (LP: #1487197) so the test needed
some improving.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:2875
http://jenkins.qa.ubuntu.com/job/mir-ci/4659/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3645
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/mir-clang-ts-vivid-amd64-build/66
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2556
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3595
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/808/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3595
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3595/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/6364
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/22776

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:2876
http://jenkins.qa.ubuntu.com/job/mir-ci/4668/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/3658
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/mir-clang-ts-vivid-amd64-build/79
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/2569
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/3608
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/817
        deb: http://jenkins.qa.ubuntu.com/job/mir-wily-amd64-ci/817/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3608
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/3608/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/6376
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/22793

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

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

I think this is OK, but I'm having trouble being sure.

review: Approve

[Kevin DuBois (kdub)]

alright

review: Approve

=== modified file 'tests/unit-tests/compositor/test_buffer_queue.cpp'
--- tests/unit-tests/compositor/test_buffer_queue.cpp	2015-08-21 02:02:07 +0000
+++ tests/unit-tests/compositor/test_buffer_queue.cpp	2015-08-25 02:45:03 +0000
@@ -194,17 +194,6 @@
    }
 }
 
-std::chrono::milliseconds const throttled_compositor_rate(10);
-void throttled_compositor_thread(mc::BufferQueue &bundle,
-                                 std::atomic<bool> &done)
-{
-   while (!done)
-   {
-       bundle.compositor_release(bundle.compositor_acquire(nullptr));
-       std::this_thread::sleep_for(throttled_compositor_rate);
-   }
-}
-
 void overlapping_compositor_thread(mc::BufferQueue &bundle,
                                    std::atomic<bool> &done)
 {
@@ -216,7 +205,7 @@
    {
        b[i^1] = bundle.compositor_acquire(nullptr);
        bundle.compositor_release(b[i]);
-       std::this_thread::sleep_for(throttled_compositor_rate);
+       std::this_thread::sleep_for(std::chrono::milliseconds(10));
        i ^= 1;
    }
 
@@ -1530,62 +1519,118 @@
 TEST_P(WithThreeOrMoreBuffers, queue_size_scales_with_client_performance)
 {
     q.allow_framedropping(false);
-
-    std::atomic<bool> done(false);
-    auto unblock = [&done] { done = true; };
-
-    // To emulate a "fast" client we use a "slow" compositor
-    mt::AutoUnblockThread compositor(unblock,
-       throttled_compositor_thread, std::ref(q), std::ref(done));
-
     std::unordered_set<mg::Buffer *> buffers_acquired;
 
     int const delay = 3;
     q.set_scaling_delay(delay);
 
-    for (int frame = 0; frame < 10; frame++)
+    for (int frame = 0; frame < 10;)
     {
-        auto handle = client_acquire_async(q);
-        handle->wait_for(std::chrono::seconds(1));
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-
-        if (frame > delay)
-            buffers_acquired.insert(handle->buffer());
-        handle->release_buffer();
+        std::shared_ptr<AcquireWaitHandle> client;
+        do
+        {
+            client = client_acquire_async(q);
+            if (client->has_acquired_buffer())
+            {
+                if (frame > delay)
+                    buffers_acquired.insert(client->buffer());
+                client->release_buffer();
+                client.reset();
+            }
+        } while (!client);
+
+        while (q.buffers_ready_for_compositor(nullptr))
+        {
+            q.compositor_release(q.compositor_acquire(nullptr));
+            ++frame;
+        }
+
+        if (client->has_acquired_buffer())
+        {
+            if (frame > delay)
+                buffers_acquired.insert(client->buffer());
+            client->release_buffer();
+            client.reset();
+        }
     }
     // Expect double-buffers for fast clients
     EXPECT_THAT(buffers_acquired.size(), Eq(2));
 
     // Now check what happens if the client becomes slow...
     buffers_acquired.clear();
-    for (int frame = 0; frame < 10; frame++)
+    for (int frame = 0; frame < 10;)
     {
-        auto handle = client_acquire_async(q);
-        handle->wait_for(std::chrono::seconds(1));
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-
-        if (frame > delay)
-            buffers_acquired.insert(handle->buffer());
-
-        // Client is just too slow to keep up:
-        std::this_thread::sleep_for(throttled_compositor_rate * 1.5);
-
-        handle->release_buffer();
+        std::shared_ptr<AcquireWaitHandle> client;
+        do
+        {
+            client = client_acquire_async(q);
+            if (client->has_acquired_buffer())
+            {
+                if (frame > delay)
+                    buffers_acquired.insert(client->buffer());
+                client->release_buffer();
+                client.reset();
+            }
+        } while (!client);
+
+        while (q.buffers_ready_for_compositor(nullptr))
+        {
+            q.compositor_release(q.compositor_acquire(nullptr));
+            ++frame;
+        }
+
+        if (client->has_acquired_buffer())
+        {
+            if (frame > delay)
+                buffers_acquired.insert(client->buffer());
+            client->release_buffer();
+            client.reset();
+        }
+
+        // Balance compositor consumption with client production:
+        while (q.buffers_ready_for_compositor(nullptr))
+        {
+            q.compositor_release(q.compositor_acquire(nullptr));
+            ++frame;
+        }
+
+        // Imbalance: Compositor is now requesting more than the client does:
+        q.compositor_release(q.compositor_acquire(nullptr));
+        ++frame;
     }
     // Expect at least triple buffers for sluggish clients
     EXPECT_THAT(buffers_acquired.size(), Ge(3));
 
     // And what happens if the client becomes fast again?...
     buffers_acquired.clear();
-    for (int frame = 0; frame < 10; frame++)
+    for (int frame = 0; frame < 10;)
     {
-        auto handle = client_acquire_async(q);
-        handle->wait_for(std::chrono::seconds(1));
-        ASSERT_THAT(handle->has_acquired_buffer(), Eq(true));
-
-        if (frame > delay)
-            buffers_acquired.insert(handle->buffer());
-        handle->release_buffer();
+        std::shared_ptr<AcquireWaitHandle> client;
+        do
+        {
+            client = client_acquire_async(q);
+            if (client->has_acquired_buffer())
+            {
+                if (frame > delay)
+                    buffers_acquired.insert(client->buffer());
+                client->release_buffer();
+                client.reset();
+            }
+        } while (!client);
+
+        while (q.buffers_ready_for_compositor(nullptr))
+        {
+            q.compositor_release(q.compositor_acquire(nullptr));
+            ++frame;
+        }
+
+        if (client->has_acquired_buffer())
+        {
+            if (frame > delay)
+                buffers_acquired.insert(client->buffer());
+            client->release_buffer();
+            client.reset();
+        }
     }
     // Expect double-buffers for fast clients
     EXPECT_THAT(buffers_acquired.size(), Eq(2));