1
=== modified file 'tests/acceptance-tests/test_latency.cpp'
2
--- tests/acceptance-tests/test_latency.cpp	2016-04-11 16:56:16 +0000
3
+++ tests/acceptance-tests/test_latency.cpp	2016-04-12 04:59:57 +0000
4
@@ -32,7 +32,7 @@
5
32
#include <gtest/gtest.h>
32
#include <gtest/gtest.h>
6
33
#include <gmock/gmock.h>
33
#include <gmock/gmock.h>
7
34
#include <deque>
34
#include <deque>
9
35
35
#include <atomic>
10
36
#include <mutex>
36
#include <mutex>
11
37
#include <condition_variable>
37
#include <condition_variable>
12
38
38
13
@@ -116,6 +116,12 @@
14
116
    };
116
    };
15
117
    std::deque<Submission> submissions;
117
    std::deque<Submission> submissions;
16
118
};
118
};
17
119
18
120
struct Options
19
121
{
20
122
    std::atomic_bool simulate_overlays{false};
21
123
};
22
124
23
119
/*
125
/*
24
120
 * Note: we're not aiming to check performance in terms of CPU or GPU time processing
126
 * Note: we're not aiming to check performance in terms of CPU or GPU time processing
25
121
 * the incoming buffers. Rather, we're checking that we don't have any intrinsic
127
 * the incoming buffers. Rather, we're checking that we don't have any intrinsic
26
@@ -124,6 +130,8 @@
27
124
class IdCollectingDB : public mtd::NullDisplayBuffer
130
class IdCollectingDB : public mtd::NullDisplayBuffer
28
125
{
131
{
29
126
public:
132
public:
30
133
    IdCollectingDB(Options const& opt) : options{opt} {}
31
134
32
127
    mir::geometry::Rectangle view_area() const override
135
    mir::geometry::Rectangle view_area() const override
33
128
    {
136
    {
34
129
        return {{0,0}, {1920, 1080}};
137
        return {{0,0}, {1920, 1080}};
35
@@ -131,24 +139,43 @@
36
131
139
37
132
    bool post_renderables_if_optimizable(mg::RenderableList const& renderables) override
140
    bool post_renderables_if_optimizable(mg::RenderableList const& renderables) override
38
133
    {
141
    {
39
142
        if (options.simulate_overlays)
40
143
            prev_onscreen = next_onscreen;
41
144
42
134
        //the surface will be the frontmost of the renderables
145
        //the surface will be the frontmost of the renderables
43
135
        if (!renderables.empty())
146
        if (!renderables.empty())
45
136
            last = renderables.front()->buffer()->id();
147
        {
46
148
            auto buffer = renderables.front()->buffer();
47
149
            the_last_id = buffer->id();
48
150
            if (options.simulate_overlays)
49
151
                next_onscreen = buffer;
50
152
        }
51
137
153
52
138
        return true;
154
        return true;
53
139
    }
155
    }
54
156
55
157
    void swap_completed()
56
158
    {
57
159
        prev_onscreen.reset();
58
160
    }
59
161
60
140
    mg::BufferID last_id()
162
    mg::BufferID last_id()
61
141
    {
163
    {
63
142
        return last;
164
        return the_last_id;
64
143
    }
165
    }
65
144
private:
166
private:
67
145
    mg::BufferID last{0};
167
    Options const& options;
68
168
    mg::BufferID the_last_id{0};
69
169
    std::shared_ptr<mg::Buffer> next_onscreen, prev_onscreen;
70
146
};
170
};
71
147
171
72
148
class TimeTrackingGroup : public mtd::NullDisplaySyncGroup
172
class TimeTrackingGroup : public mtd::NullDisplaySyncGroup
73
149
{
173
{
74
150
public:
174
public:
76
151
    TimeTrackingGroup(Stats& stats) : stats{stats} {}
175
    TimeTrackingGroup(Stats& stats, Options const& opt)
77
176
        : stats{stats}, db(opt)
78
177
    {
79
178
    }
80
152
179
81
153
    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
180
    void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
82
154
    {
181
    {
83
@@ -175,6 +202,7 @@
84
175
         * latency would never exceed 1.0.  (LP: #1447947)
202
         * latency would never exceed 1.0.  (LP: #1447947)
85
176
         */
203
         */
86
177
        std::this_thread::sleep_for(vblank_interval);
204
        std::this_thread::sleep_for(vblank_interval);
87
205
        db.swap_completed();
88
178
    }
206
    }
89
179
207
90
180
    float average_latency()
208
    float average_latency()
91
@@ -224,8 +252,8 @@
92
224
252
93
225
struct TimeTrackingDisplay : mtd::NullDisplay
253
struct TimeTrackingDisplay : mtd::NullDisplay
94
226
{
254
{
97
227
    TimeTrackingDisplay(Stats& stats)
255
    TimeTrackingDisplay(Stats& stats, Options const& opt)
98
228
        : group{stats}
256
        : group(stats, opt)
99
229
    {
257
    {
100
230
    }
258
    }
101
231
259
102
@@ -240,6 +268,7 @@
103
240
{
268
{
104
241
    void SetUp() override
269
    void SetUp() override
105
242
    {
270
    {
106
271
        options.simulate_overlays = false;
107
243
        preset_display(mt::fake_shared(display));
272
        preset_display(mt::fake_shared(display));
108
244
        mtf::ConnectedClientHeadlessServer::SetUp();
273
        mtf::ConnectedClientHeadlessServer::SetUp();
109
245
274
110
@@ -259,7 +288,8 @@
111
259
    }
288
    }
112
260
289
113
261
    Stats stats;
290
    Stats stats;
115
262
    TimeTrackingDisplay display{stats};
291
    Options options;
116
292
    TimeTrackingDisplay display{stats, options};
117
263
    unsigned int test_submissions{100};
293
    unsigned int test_submissions{100};
118
264
294
119
265
    // We still have a margin for error here. The client and server will
295
    // We still have a margin for error here. The client and server will
120
@@ -296,6 +326,39 @@
121
296
    EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));
326
    EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));
122
297
}
327
}
123
298
328
124
329
/*
125
330
 * Overlays/bypass wasn't ever expected to reduce latency, but a quirk of
126
331
 * the algorithm means it does. When you have a buffer overlayed on screen,
127
332
 * you need to hold it till after you have guaranteed that it's been replaced
128
333
 * and definitely not on screen any more. This means the compositor holds
129
334
 * an overlay/bypass buffer for one frame longer than it would for GL.
130
335
 */
131
336
TEST_F(ClientLatency, overlayed_client_has_latency_nbuffers_minus_2)
132
337
{
133
338
    using namespace testing;
134
339
135
340
    options.simulate_overlays = true;
136
341
137
342
    auto stream = mir_surface_get_buffer_stream(surface);
138
343
    for(auto i = 0u; i < test_submissions; i++) {
139
344
        auto submission_id = mir_debug_surface_current_buffer_id(surface);
140
345
        stats.record_submission(submission_id);
141
346
        mir_buffer_stream_swap_buffers_sync(stream);
142
347
    }
143
348
144
349
    ASSERT_TRUE(stats.wait_for_posts(test_submissions,
145
350
                                     std::chrono::seconds(60)));
146
351
147
352
    float const expected_max_latency = expected_client_buffers - 2;
148
353
149
354
    if (server.get_options()->get<bool>(mtd::logging_opt))
150
355
        display.group.dump_latency();
151
356
152
357
    auto observed_latency = display.group.average_latency();
153
358
154
359
    EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));
155
360
}
156
361
157
299
TEST_F(ClientLatency, latency_is_limited_to_nbuffers)
362
TEST_F(ClientLatency, latency_is_limited_to_nbuffers)
158
300
{
363
{
159
301
    using namespace testing;
364
    using namespace testing;
Status:	Work in progress
Proposed branch:	lp:~vanvugt/mir/ClientLatency-of-overlays
Merge into:	lp:mir
Prerequisite:	lp:~vanvugt/mir/fix-ClientLatency-of-zero
Diff against target:	159 lines (+71/-8) 1 file modified tests/acceptance-tests/test_latency.cpp (+71/-8)
To merge this branch:	bzr merge lp:~vanvugt/mir/ClientLatency-of-overlays
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Needs Fixing on 2016-04-12
Mir development team		2016-04-08	Pending
Review via email: mp+291348@code.launchpad.net
1	=== modified file 'tests/acceptance-tests/test_latency.cpp'
2	--- tests/acceptance-tests/test_latency.cpp 2016-04-11 16:56:16 +0000
3	+++ tests/acceptance-tests/test_latency.cpp 2016-04-12 04:59:57 +0000
4	@@ -32,7 +32,7 @@
5	32	#include <gtest/gtest.h>	32	#include <gtest/gtest.h>
6	33	#include <gmock/gmock.h>	33	#include <gmock/gmock.h>
7	34	#include <deque>	34	#include <deque>
9	35		35	#include <atomic>
10	36	#include <mutex>	36	#include <mutex>
11	37	#include <condition_variable>	37	#include <condition_variable>
12	38		38
13	@@ -116,6 +116,12 @@
14	116	};	116	};
15	117	std::deque<Submission> submissions;	117	std::deque<Submission> submissions;
16	118	};	118	};
17			119
18			120	struct Options
19			121	{
20			122	std::atomic_bool simulate_overlays{false};
21			123	};
22			124
23	119	/*	125	/*
24	120	* Note: we're not aiming to check performance in terms of CPU or GPU time processing	126	* Note: we're not aiming to check performance in terms of CPU or GPU time processing
25	121	* the incoming buffers. Rather, we're checking that we don't have any intrinsic	127	* the incoming buffers. Rather, we're checking that we don't have any intrinsic
26	@@ -124,6 +130,8 @@
27	124	class IdCollectingDB : public mtd::NullDisplayBuffer	130	class IdCollectingDB : public mtd::NullDisplayBuffer
28	125	{	131	{
29	126	public:	132	public:
30			133	IdCollectingDB(Options const& opt) : options{opt} {}
31			134
32	127	mir::geometry::Rectangle view_area() const override	135	mir::geometry::Rectangle view_area() const override
33	128	{	136	{
34	129	return {{0,0}, {1920, 1080}};	137	return {{0,0}, {1920, 1080}};
35	@@ -131,24 +139,43 @@
36	131		139
37	132	bool post_renderables_if_optimizable(mg::RenderableList const& renderables) override	140	bool post_renderables_if_optimizable(mg::RenderableList const& renderables) override
38	133	{	141	{
39			142	if (options.simulate_overlays)
40			143	prev_onscreen = next_onscreen;
41			144
42	134	//the surface will be the frontmost of the renderables	145	//the surface will be the frontmost of the renderables
43	135	if (!renderables.empty())	146	if (!renderables.empty())
45	136	last = renderables.front()->buffer()->id();	147	{
46			148	auto buffer = renderables.front()->buffer();
47			149	the_last_id = buffer->id();
48			150	if (options.simulate_overlays)
49			151	next_onscreen = buffer;
50			152	}
51	137		153
52	138	return true;	154	return true;
53	139	}	155	}
54			156
55			157	void swap_completed()
56			158	{
57			159	prev_onscreen.reset();
58			160	}
59			161
60	140	mg::BufferID last_id()	162	mg::BufferID last_id()
61	141	{	163	{
63	142	return last;	164	return the_last_id;
64	143	}	165	}
65	144	private:	166	private:
67	145	mg::BufferID last{0};	167	Options const& options;
68			168	mg::BufferID the_last_id{0};
69			169	std::shared_ptr<mg::Buffer> next_onscreen, prev_onscreen;
70	146	};	170	};
71	147		171
72	148	class TimeTrackingGroup : public mtd::NullDisplaySyncGroup	172	class TimeTrackingGroup : public mtd::NullDisplaySyncGroup
73	149	{	173	{
74	150	public:	174	public:
76	151	TimeTrackingGroup(Stats& stats) : stats{stats} {}	175	TimeTrackingGroup(Stats& stats, Options const& opt)
77			176	: stats{stats}, db(opt)
78			177	{
79			178	}
80	152		179
81	153	void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override	180	void for_each_display_buffer(std::function<void(mg::DisplayBuffer&)> const& f) override
82	154	{	181	{
83	@@ -175,6 +202,7 @@
84	175	* latency would never exceed 1.0. (LP: #1447947)	202	* latency would never exceed 1.0. (LP: #1447947)
85	176	*/	203	*/
86	177	std::this_thread::sleep_for(vblank_interval);	204	std::this_thread::sleep_for(vblank_interval);
87			205	db.swap_completed();
88	178	}	206	}
89	179		207
90	180	float average_latency()	208	float average_latency()
91	@@ -224,8 +252,8 @@
92	224		252
93	225	struct TimeTrackingDisplay : mtd::NullDisplay	253	struct TimeTrackingDisplay : mtd::NullDisplay
94	226	{	254	{
97	227	TimeTrackingDisplay(Stats& stats)	255	TimeTrackingDisplay(Stats& stats, Options const& opt)
98	228	: group{stats}	256	: group(stats, opt)
99	229	{	257	{
100	230	}	258	}
101	231		259
102	@@ -240,6 +268,7 @@
103	240	{	268	{
104	241	void SetUp() override	269	void SetUp() override
105	242	{	270	{
106			271	options.simulate_overlays = false;
107	243	preset_display(mt::fake_shared(display));	272	preset_display(mt::fake_shared(display));
108	244	mtf::ConnectedClientHeadlessServer::SetUp();	273	mtf::ConnectedClientHeadlessServer::SetUp();
109	245		274
110	@@ -259,7 +288,8 @@
111	259	}	288	}
112	260		289
113	261	Stats stats;	290	Stats stats;
115	262	TimeTrackingDisplay display{stats};	291	Options options;
116			292	TimeTrackingDisplay display{stats, options};
117	263	unsigned int test_submissions{100};	293	unsigned int test_submissions{100};
118	264		294
119	265	// We still have a margin for error here. The client and server will	295	// We still have a margin for error here. The client and server will
120	@@ -296,6 +326,39 @@
121	296	EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));	326	EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));
122	297	}	327	}
123	298		328
124			329	/*
125			330	* Overlays/bypass wasn't ever expected to reduce latency, but a quirk of
126			331	* the algorithm means it does. When you have a buffer overlayed on screen,
127			332	* you need to hold it till after you have guaranteed that it's been replaced
128			333	* and definitely not on screen any more. This means the compositor holds
129			334	* an overlay/bypass buffer for one frame longer than it would for GL.
130			335	*/
131			336	TEST_F(ClientLatency, overlayed_client_has_latency_nbuffers_minus_2)
132			337	{
133			338	using namespace testing;
134			339
135			340	options.simulate_overlays = true;
136			341
137			342	auto stream = mir_surface_get_buffer_stream(surface);
138			343	for(auto i = 0u; i < test_submissions; i++) {
139			344	auto submission_id = mir_debug_surface_current_buffer_id(surface);
140			345	stats.record_submission(submission_id);
141			346	mir_buffer_stream_swap_buffers_sync(stream);
142			347	}
143			348
144			349	ASSERT_TRUE(stats.wait_for_posts(test_submissions,
145			350	std::chrono::seconds(60)));
146			351
147			352	float const expected_max_latency = expected_client_buffers - 2;
148			353
149			354	if (server.get_options()->get<bool>(mtd::logging_opt))
150			355	display.group.dump_latency();
151			356
152			357	auto observed_latency = display.group.average_latency();
153			358
154			359	EXPECT_THAT(observed_latency, Lt(expected_max_latency+error_margin));
155			360	}
156			361
157	299	TEST_F(ClientLatency, latency_is_limited_to_nbuffers)	362	TEST_F(ClientLatency, latency_is_limited_to_nbuffers)
158	300	{	363	{
159	301	using namespace testing;	364	using namespace testing;