1
=== modified file 'src/server/compositor/buffer_queue.cpp'
2
--- src/server/compositor/buffer_queue.cpp	2015-01-22 09:12:04 +0000
3
+++ src/server/compositor/buffer_queue.cpp	2015-02-17 06:41:51 +0000
4
@@ -271,25 +271,6 @@
5
271
    if (nbuffers <= 1)
271
    if (nbuffers <= 1)
6
272
        return;
272
        return;
7
273
273
8
274
    /*
9
275
     * We can't release the current_compositor_buffer because we need to keep
10
276
     * a compositor buffer always-available. But there might be a new
11
277
     * compositor buffer available to take its place immediately. Moving to
12
278
     * that one immediately will free up the old compositor buffer, allowing
13
279
     * us to call back the client with a buffer where otherwise we couldn't.
14
280
     */
15
281
    if (current_compositor_buffer == buffer.get() &&
16
282
        !ready_to_composite_queue.empty())
17
283
    {
18
284
        current_compositor_buffer = pop(ready_to_composite_queue);
19
285
20
286
        // Ensure current_compositor_buffer gets reused by the next
21
287
        // compositor_acquire:
22
288
        current_buffer_users.clear();
23
289
        void const* const impossible_user_id = this;
24
290
        current_buffer_users.push_back(impossible_user_id);
25
291
    }
26
292
27
293
    if (current_compositor_buffer != buffer.get())
274
    if (current_compositor_buffer != buffer.get())
28
294
        release(buffer.get(), std::move(lock));
275
        release(buffer.get(), std::move(lock));
29
295
}
276
}
30
296
277
31
=== modified file 'tests/unit-tests/compositor/test_buffer_queue.cpp'
32
--- tests/unit-tests/compositor/test_buffer_queue.cpp	2015-01-22 09:12:04 +0000
33
+++ tests/unit-tests/compositor/test_buffer_queue.cpp	2015-02-17 06:41:51 +0000
34
@@ -489,6 +489,44 @@
35
489
    }
489
    }
36
490
}
490
}
37
491
491
38
492
TEST_F(BufferQueueTest, multiple_fast_compositors_are_in_sync)
39
493
{  // Regression test for LP: #1420678
40
494
    for (int nbuffers = 3; nbuffers <= max_nbuffers_to_test; ++nbuffers)
41
495
    {
42
496
        mc::BufferQueue q(nbuffers, allocator, basic_properties, policy_factory);
43
497
44
498
        // Client generates first frame
45
499
        auto handle1 = client_acquire_async(q);
46
500
        ASSERT_TRUE(handle1->has_acquired_buffer());
47
501
        auto client_id1 = handle1->id();
48
502
        handle1->release_buffer();
49
503
50
504
        // Client generates second frame
51
505
        auto handle2 = client_acquire_async(q);
52
506
        ASSERT_TRUE(handle2->has_acquired_buffer());
53
507
        auto client_id2 = handle2->id();
54
508
        handle2->release_buffer();
55
509
56
510
        // Many monitors... verify they all get the first frame.
57
511
        for (int monitor = 0; monitor < 10; monitor++)
58
512
        {
59
513
            void const* user_id = reinterpret_cast<void const*>(monitor);
60
514
            auto comp_buffer = q.compositor_acquire(user_id);
61
515
            ASSERT_EQ(client_id1, comp_buffer->id());
62
516
            q.compositor_release(comp_buffer);
63
517
        }
64
518
65
519
        // Still many monitors... verify they all get the second frame.
66
520
        for (int monitor = 0; monitor < 10; monitor++)
67
521
        {
68
522
            void const* user_id = reinterpret_cast<void const*>(monitor);
69
523
            auto comp_buffer = q.compositor_acquire(user_id);
70
524
            ASSERT_EQ(client_id2, comp_buffer->id());
71
525
            q.compositor_release(comp_buffer);
72
526
        }
73
527
    }
74
528
}
75
529
76
492
TEST_F(BufferQueueTest, compositor_acquires_frames_in_order)
530
TEST_F(BufferQueueTest, compositor_acquires_frames_in_order)
77
493
{
531
{
78
494
    for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
532
    for (int nbuffers = 2; nbuffers <= max_nbuffers_to_test; ++nbuffers)
79
@@ -1236,6 +1274,14 @@
80
1236
    q.client_release(client_acquire_sync(q));
1274
    q.client_release(client_acquire_sync(q));
81
1237
1275
82
1238
    q.compositor_release(b);
1276
    q.compositor_release(b);
83
1277
84
1278
    /*
85
1279
     * Update to the original test case; This additional compositor acquire
86
1280
     * represents the fixing of LP: #1395581 in the compositor logic.
87
1281
     */
88
1282
    if (q.buffers_ready_for_compositor(this))
89
1283
        q.compositor_release(q.compositor_acquire(this));
90
1284
91
1239
    auto handle = client_acquire_async(q);
1285
    auto handle = client_acquire_async(q);
92
1240
    // With the fix, a buffer will be available instantaneously:
1286
    // With the fix, a buffer will be available instantaneously:
93
1241
    ASSERT_TRUE(handle->has_acquired_buffer());
1287
    ASSERT_TRUE(handle->has_acquired_buffer());
94
@@ -1272,6 +1318,13 @@
95
1272
    
1318
    
96
1273
        q.compositor_release(b);
1319
        q.compositor_release(b);
97
1274
1320
98
1321
        /*
99
1322
         * Update to the original test case; This additional compositor acquire
100
1323
         * represents the fixing of LP: #1395581 in the compositor logic.
101
1324
         */
102
1325
        if (q.buffers_ready_for_compositor(this))
103
1326
            q.compositor_release(q.compositor_acquire(this));
104
1327
105
1275
        auto z = client_acquire_async(q);
1328
        auto z = client_acquire_async(q);
106
1276
        ASSERT_TRUE(z->has_acquired_buffer());
1329
        ASSERT_TRUE(z->has_acquired_buffer());
107
1277
        z->release_buffer();
1330
        z->release_buffer();
Reviewer	Review Type	Date Requested	Status
Chris Halse Rogers			Approve on 2015-02-17
PS Jenkins bot (community)	continuous-integration		Approve on 2015-02-13
Alan Griffiths		2015-02-12	Approve on 2015-02-12
Review via email: mp+249456@code.launchpad.net