1
=== modified file 'src/server/compositor/multi_threaded_compositor.cpp'
2
--- src/server/compositor/multi_threaded_compositor.cpp	2014-09-06 14:28:26 +0000
3
+++ src/server/compositor/multi_threaded_compositor.cpp	2014-09-09 03:47:53 +0000
4
@@ -22,6 +22,7 @@
5
22
#include "mir/compositor/display_buffer_compositor.h"
22
#include "mir/compositor/display_buffer_compositor.h"
6
23
#include "mir/compositor/display_buffer_compositor_factory.h"
23
#include "mir/compositor/display_buffer_compositor_factory.h"
7
24
#include "mir/compositor/scene.h"
24
#include "mir/compositor/scene.h"
8
25
#include "mir/compositor/scene_element.h"
9
25
#include "mir/compositor/compositor_report.h"
26
#include "mir/compositor/compositor_report.h"
10
26
#include "mir/scene/legacy_scene_change_notification.h"
27
#include "mir/scene/legacy_scene_change_notification.h"
11
27
#include "mir/scene/surface_observer.h"
28
#include "mir/scene/surface_observer.h"
12
@@ -60,6 +61,26 @@
13
60
    std::function<void()> const apply;
61
    std::function<void()> const apply;
14
61
};
62
};
15
62
63
16
64
void drop_frames(mc::Scene& scene, int nframes)
17
65
{
18
66
    // Consume nframes+1. The +1 is required for force the multi-monitor
19
67
    // frame sync logic to release old buffers. It will only do so on the
20
68
    // second and subsequent calls for a given CompositorID (0).
21
69
22
70
    for (int f = 0; f < nframes + 1; ++f)
23
71
    {
24
72
        auto const& elements = scene.scene_elements_for(0);
25
73
        for (auto& element : elements)
26
74
            (void)element->renderable()->buffer();
27
75
    }
28
76
}
29
77
30
78
/*
31
79
 * Annoyingly, we can't use milliseconds::max() because that's actually
32
80
 * negative and will trigger immediate wakeups (!?)
33
81
 */
34
82
std::chrono::milliseconds const forever(INT_MAX);
35
83
36
63
}
84
}
37
64
85
38
65
namespace mir
86
namespace mir
39
@@ -123,8 +144,14 @@
40
123
        std::unique_lock<std::mutex> lock{run_mutex};
144
        std::unique_lock<std::mutex> lock{run_mutex};
41
124
        while (running)
145
        while (running)
42
125
        {
146
        {
45
126
            /* Wait until compositing has been scheduled or we are stopped */
147
            while (running && !frames_scheduled)
46
127
            run_cv.wait(lock, [&]{ return (frames_scheduled > 0) || !running; });
148
            {
47
149
                auto status = run_cv.wait_for(lock, timeout);
48
150
                if (!frames_scheduled && status == std::cv_status::timeout)
49
151
                    frames_scheduled = deferred_frames_scheduled;
50
152
            }
51
153
52
154
            timeout = forever;
53
128
155
54
129
            /*
156
            /*
55
130
             * Check if we are running before compositing, since we may have
157
             * Check if we are running before compositing, since we may have
56
@@ -153,11 +180,20 @@
57
153
        mir::terminate_with_current_exception();
180
        mir::terminate_with_current_exception();
58
154
    }
181
    }
59
155
182
61
156
    void schedule_compositing(int num_frames)
183
    void schedule_compositing(int num_frames,
62
184
                              std::chrono::milliseconds delay =
63
185
                                  std::chrono::milliseconds::zero())
64
157
    {
186
    {
65
158
        std::lock_guard<std::mutex> lock{run_mutex};
187
        std::lock_guard<std::mutex> lock{run_mutex};
66
159
188
68
160
        if (num_frames > frames_scheduled)
189
        if (delay != std::chrono::milliseconds::zero())
69
190
        {
70
191
            timeout = delay;
71
192
            deferred_frames_scheduled = num_frames;
72
193
            frames_scheduled = 0;
73
194
            run_cv.notify_one();
74
195
        }
75
196
        else if (num_frames > frames_scheduled)
76
161
        {
197
        {
77
162
            frames_scheduled = num_frames;
198
            frames_scheduled = num_frames;
78
163
            run_cv.notify_one();
199
            run_cv.notify_one();
79
@@ -176,6 +212,8 @@
80
176
    mg::DisplayBuffer& buffer;
212
    mg::DisplayBuffer& buffer;
81
177
    bool running;
213
    bool running;
82
178
    int frames_scheduled;
214
    int frames_scheduled;
83
215
    int deferred_frames_scheduled = 0;
84
216
    std::chrono::milliseconds timeout = forever;
85
179
    std::mutex run_mutex;
217
    std::mutex run_mutex;
86
180
    std::condition_variable run_cv;
218
    std::condition_variable run_cv;
87
181
    std::shared_ptr<CompositorReport> const report;
219
    std::shared_ptr<CompositorReport> const report;
88
@@ -189,13 +227,15 @@
89
189
    std::shared_ptr<mc::Scene> const& scene,
227
    std::shared_ptr<mc::Scene> const& scene,
90
190
    std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
228
    std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
91
191
    std::shared_ptr<CompositorReport> const& compositor_report,
229
    std::shared_ptr<CompositorReport> const& compositor_report,
93
192
    bool compose_on_start)
230
    bool compose_on_start,
94
231
    std::chrono::milliseconds restart_delay)
95
193
    : display{display},
232
    : display{display},
96
194
      scene{scene},
233
      scene{scene},
97
195
      display_buffer_compositor_factory{db_compositor_factory},
234
      display_buffer_compositor_factory{db_compositor_factory},
98
196
      report{compositor_report},
235
      report{compositor_report},
99
197
      state{CompositorState::stopped},
236
      state{CompositorState::stopped},
100
198
      compose_on_start{compose_on_start},
237
      compose_on_start{compose_on_start},
101
238
      restart_delay{restart_delay},
102
199
      thread_pool{1}
239
      thread_pool{1}
103
200
{
240
{
104
201
    observer = std::make_shared<ms::LegacySceneChangeNotification>(
241
    observer = std::make_shared<ms::LegacySceneChangeNotification>(
105
@@ -214,13 +254,14 @@
106
214
    stop();
254
    stop();
107
215
}
255
}
108
216
256
110
217
void mc::MultiThreadedCompositor::schedule_compositing(int num)
257
void mc::MultiThreadedCompositor::schedule_compositing(int num,
111
258
                                       std::chrono::milliseconds delay)
112
218
{
259
{
113
219
    std::unique_lock<std::mutex> lk(state_guard);
260
    std::unique_lock<std::mutex> lk(state_guard);
114
220
261
115
221
    report->scheduled();
262
    report->scheduled();
116
222
    for (auto& f : thread_functors)
263
    for (auto& f : thread_functors)
118
223
        f->schedule_compositing(num);
264
        f->schedule_compositing(num, delay);
119
224
}
265
}
120
225
266
121
226
void mc::MultiThreadedCompositor::start()
267
void mc::MultiThreadedCompositor::start()
122
@@ -249,8 +290,11 @@
123
249
    /* Optional first render */
290
    /* Optional first render */
124
250
    if (compose_on_start)
291
    if (compose_on_start)
125
251
    {
292
    {
126
293
        int const max_buffer_queue_depth = 3;
127
294
        drop_frames(*scene, max_buffer_queue_depth);
128
295
129
252
        lk.unlock();
296
        lk.unlock();
131
253
        schedule_compositing(1);
297
        schedule_compositing(1, restart_delay);
132
254
    }
298
    }
133
255
}
299
}
134
256
300
135
257
301
136
=== modified file 'src/server/compositor/multi_threaded_compositor.h'
137
--- src/server/compositor/multi_threaded_compositor.h	2014-09-06 14:28:26 +0000
138
+++ src/server/compositor/multi_threaded_compositor.h	2014-09-09 03:47:53 +0000
139
@@ -26,6 +26,8 @@
140
26
#include <memory>
26
#include <memory>
141
27
#include <vector>
27
#include <vector>
142
28
#include <future>
28
#include <future>
143
29
#include <thread>
144
30
#include <chrono>
145
29
31
146
30
namespace mir
32
namespace mir
147
31
{
33
{
148
@@ -61,7 +63,9 @@
149
61
                            std::shared_ptr<Scene> const& scene,
63
                            std::shared_ptr<Scene> const& scene,
150
62
                            std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
64
                            std::shared_ptr<DisplayBufferCompositorFactory> const& db_compositor_factory,
151
63
                            std::shared_ptr<CompositorReport> const& compositor_report,
65
                            std::shared_ptr<CompositorReport> const& compositor_report,
153
64
                            bool compose_on_start);
66
                            bool compose_on_start,
154
67
                            std::chrono::milliseconds restart_delay =
155
68
                                std::chrono::milliseconds(500));
156
65
    ~MultiThreadedCompositor();
69
    ~MultiThreadedCompositor();
157
66
70
158
67
    void start();
71
    void start();
159
@@ -82,8 +86,10 @@
160
82
    std::mutex state_guard;
86
    std::mutex state_guard;
161
83
    CompositorState state;
87
    CompositorState state;
162
84
    bool compose_on_start;
88
    bool compose_on_start;
163
89
    std::chrono::milliseconds const restart_delay;
164
85
90
166
86
    void schedule_compositing(int number_composites);
91
    void schedule_compositing(int number_composites,
167
92
          std::chrono::milliseconds delay = std::chrono::milliseconds::zero());
168
87
93
169
88
    std::shared_ptr<mir::scene::Observer> observer;
94
    std::shared_ptr<mir::scene::Observer> observer;
170
89
    mir::thread::BasicThreadPool thread_pool;
95
    mir::thread::BasicThreadPool thread_pool;
171
90
96
172
=== modified file 'tests/unit-tests/compositor/test_multi_threaded_compositor.cpp'
173
--- tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2014-09-05 03:37:19 +0000
174
+++ tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2014-09-09 03:47:53 +0000
175
@@ -608,6 +608,120 @@
176
608
    compositor.stop();
608
    compositor.stop();
177
609
}
609
}
178
610
610
179
611
TEST(MultiThreadedCompositor, restart_flushes_the_scene)
180
612
{
181
613
    using namespace testing;
182
614
183
615
    int const ndisplays = 1;
184
616
    int const buffer_queue_depth = 3;
185
617
    auto display = std::make_shared<StubDisplayWithMockBuffers>(ndisplays);
186
618
    auto mock_scene = std::make_shared<mtd::MockScene>();
187
619
    auto factory = std::make_shared<NullDisplayBufferCompositorFactory>();
188
620
    auto mock_report =
189
621
        std::make_shared<testing::NiceMock<mtd::MockCompositorReport>>();
190
622
191
623
    int const nstarts = 2;
192
624
    int const nstops = nstarts;
193
625
    EXPECT_CALL(*mock_report, started())
194
626
        .Times(nstarts);
195
627
    EXPECT_CALL(*mock_report, stopped())
196
628
        .Times(nstops);
197
629
    EXPECT_CALL(*mock_scene, add_observer(_))
198
630
        .Times(nstarts);
199
631
    EXPECT_CALL(*mock_scene, remove_observer(_))
200
632
        .Times(nstarts);
201
633
202
634
    EXPECT_CALL(*mock_scene, scene_elements_for(_))
203
635
        .Times(nstarts * (buffer_queue_depth + 1))
204
636
        .WillRepeatedly(Return(mc::SceneElementSequence{}));
205
637
206
638
    mc::MultiThreadedCompositor compositor{display, mock_scene, factory,
207
639
                                           mock_report, true};
208
640
209
641
    compositor.start();
210
642
    compositor.stop();
211
643
    compositor.start();
212
644
    compositor.stop();
213
645
}
214
646
215
647
TEST(MultiThreadedCompositor, resume_on_idle_scene_is_delayed)
216
648
{
217
649
    using namespace testing;
218
650
219
651
    unsigned int const nbuffers = 3;
220
652
221
653
    auto display = std::make_shared<StubDisplay>(nbuffers);
222
654
    auto scene = std::make_shared<StubScene>();
223
655
    auto factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
224
656
225
657
    std::chrono::milliseconds const delay(500);
226
658
    mc::MultiThreadedCompositor compositor{display, scene, factory,
227
659
                                           null_report, true, delay};
228
660
229
661
    EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
230
662
231
663
    compositor.start();
232
664
233
665
    scene->emit_change_event();
234
666
    while (!factory->check_record_count_for_each_buffer(nbuffers, 1))
235
667
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
236
668
    EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 1, 1));
237
669
238
670
    compositor.stop();
239
671
240
672
    using namespace std::chrono;
241
673
    auto from = system_clock::now();
242
674
243
675
    compositor.start();
244
676
    while (!factory->check_record_count_for_each_buffer(nbuffers, 2))
245
677
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
246
678
    auto to = system_clock::now();
247
679
    auto measured_delay = duration_cast<milliseconds>(to - from);
248
680
    EXPECT_THAT(measured_delay, Ge(delay));
249
681
250
682
    compositor.stop();
251
683
}
252
684
253
685
TEST(MultiThreadedCompositor, resume_on_busy_scene_is_not_delayed)
254
686
{
255
687
    using namespace testing;
256
688
257
689
    unsigned int const nbuffers = 3;
258
690
259
691
    auto display = std::make_shared<StubDisplay>(nbuffers);
260
692
    auto scene = std::make_shared<StubScene>();
261
693
    auto factory = std::make_shared<RecordingDisplayBufferCompositorFactory>();
262
694
    std::chrono::milliseconds const long_delay(10000);
263
695
    std::chrono::milliseconds const max_frame_time(1000); // Valgrind :)
264
696
    ASSERT_LT(max_frame_time, long_delay);
265
697
    mc::MultiThreadedCompositor compositor{display, scene, factory,
266
698
                                           null_report, true, long_delay};
267
699
268
700
    EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 0, 0));
269
701
270
702
    compositor.start();
271
703
272
704
    scene->emit_change_event();
273
705
    while (!factory->check_record_count_for_each_buffer(nbuffers, 1))
274
706
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
275
707
    EXPECT_TRUE(factory->check_record_count_for_each_buffer(nbuffers, 1, 1));
276
708
277
709
    compositor.stop();
278
710
279
711
    using namespace std::chrono;
280
712
    auto from = system_clock::now();
281
713
282
714
    compositor.start();
283
715
    scene->emit_change_event();
284
716
    while (!factory->check_record_count_for_each_buffer(nbuffers, 2))
285
717
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
286
718
    auto to = system_clock::now();
287
719
    auto measured_delay = duration_cast<milliseconds>(to - from);
288
720
    EXPECT_THAT(measured_delay, Lt(max_frame_time));
289
721
290
722
    compositor.stop();
291
723
}
292
724
293
611
TEST(MultiThreadedCompositor, cleans_up_after_throw_in_start)
725
TEST(MultiThreadedCompositor, cleans_up_after_throw_in_start)
294
612
{
726
{
295
613
    unsigned int const nbuffers{3};
727
    unsigned int const nbuffers{3};
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2014-09-09
Alberto Aguirre (community)			Needs Information on 2014-08-28
Alexandros Frantzis (community)			Needs Information on 2014-08-12
Kevin DuBois (community)		2014-08-12	Needs Fixing on 2014-08-12
Review via email: mp+230436@code.launchpad.net