1
=== modified file 'debian/mir-test-tools.install'
2
--- debian/mir-test-tools.install	2016-05-03 04:36:33 +0000
3
+++ debian/mir-test-tools.install	2016-05-09 08:40:31 +0000
4
@@ -6,6 +6,7 @@
5
6
usr/bin/mir_integration_tests*
6
usr/bin/mir_integration_tests*
6
7
usr/bin/mir_performance_tests
7
usr/bin/mir_performance_tests
7
8
usr/bin/mir_glmark2_performance_test
8
usr/bin/mir_glmark2_performance_test
8
9
usr/bin/mir_compositor_performance_test
9
9
usr/bin/mir_privileged_tests
10
usr/bin/mir_privileged_tests
10
10
usr/bin/mir_test_reload_protobuf
11
usr/bin/mir_test_reload_protobuf
11
11
usr/bin/mir_test_client_*
12
usr/bin/mir_test_client_*
12
12
13
13
=== modified file 'tests/performance-tests/CMakeLists.txt'
14
--- tests/performance-tests/CMakeLists.txt	2016-04-27 09:21:20 +0000
15
+++ tests/performance-tests/CMakeLists.txt	2016-05-09 08:40:31 +0000
16
@@ -16,3 +16,10 @@
17
16
  mirserver
16
  mirserver
18
17
  ${GTEST_BOTH_LIBRARIES}
17
  ${GTEST_BOTH_LIBRARIES}
19
18
)
18
)
20
19
21
20
mir_add_wrapped_executable(mir_compositor_performance_test
22
21
  test_compositor.cpp
23
22
)
24
23
target_link_libraries(mir_compositor_performance_test
25
24
  ${GTEST_BOTH_LIBRARIES}
26
25
)
27
19
26
28
=== modified file 'tests/performance-tests/performance_tests.sh'
29
--- tests/performance-tests/performance_tests.sh	2016-04-22 05:09:40 +0000
30
+++ tests/performance-tests/performance_tests.sh	2016-05-09 08:40:31 +0000
31
@@ -30,7 +30,8 @@
32
30
30
33
31
tests_run=0
31
tests_run=0
34
32
failures=0
32
failures=0
36
33
for perf_test in mir_glmark2_performance_test
33
for perf_test in mir_glmark2_performance_test \
37
34
                 mir_compositor_performance_test
38
34
do
35
do
39
35
    title_banner "Mir Performance Tests now running: $perf_test"
36
    title_banner "Mir Performance Tests now running: $perf_test"
40
36
    tests_run=$(($tests_run + 1))
37
    tests_run=$(($tests_run + 1))
41
37
38
42
=== added file 'tests/performance-tests/test_compositor.cpp'
43
--- tests/performance-tests/test_compositor.cpp	1970-01-01 00:00:00 +0000
44
+++ tests/performance-tests/test_compositor.cpp	2016-05-09 08:40:31 +0000
45
@@ -0,0 +1,222 @@
46
1
/*
47
2
 * Copyright © 2016 Canonical Ltd.
48
3
 *
49
4
 * This program is free software: you can redistribute it and/or modify it
50
5
 * under the terms of the GNU General Public License version 3,
51
6
 * as published by the Free Software Foundation.
52
7
 *
53
8
 * This program is distributed in the hope that it will be useful,
54
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
55
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
56
11
 * GNU General Public License for more details.
57
12
 *
58
13
 * You should have received a copy of the GNU General Public License
59
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
60
15
 *
61
16
 * Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
62
17
 */
63
18
64
19
#include <gtest/gtest.h>
65
20
#include <cstdio>
66
21
#include <cstdlib>
67
22
#include <cstring>
68
23
#include <unistd.h>
69
24
#include <string>
70
25
#include <thread>
71
26
#include <initializer_list>
72
27
73
28
using namespace std::literals::chrono_literals;
74
29
75
30
namespace
76
31
{
77
32
78
33
std::string mir_bin_dir()
79
34
{
80
35
    char path[256];
81
36
    auto len = readlink("/proc/self/exe", path, sizeof(path)-1);
82
37
    if (len < 0)
83
38
        len = 0;
84
39
    path[len] = '\0';
85
40
    if (auto slash = strrchr(path, '/'))
86
41
        *slash = '\0';
87
42
    return path;
88
43
}
89
44
90
45
void kill_nicely(pid_t pid)
91
46
{
92
47
    if (kill(pid, SIGTERM) < 0)
93
48
        return;
94
49
    int const timeout = 5;
95
50
    int status, count = 0;
96
51
    while (0 == waitpid(pid, &status, WNOHANG) && count < timeout)
97
52
    {
98
53
        sleep(1);
99
54
        ++count;
100
55
    }
101
56
    kill(pid, SIGKILL);
102
57
}
103
58
104
59
int exec_cmd(char const* cmd)
105
60
{
106
61
    auto buf = strdup(cmd);
107
62
    size_t argc = 1;
108
63
    char* argv[256] = {buf};
109
64
    char *c = buf;
110
65
    while (*c)
111
66
    {
112
67
        if (*c == ' ')
113
68
        {
114
69
            *c = '\0';
115
70
            if (argc < (sizeof(argv)/sizeof(argv[0]) - 1))
116
71
            {
117
72
                argv[argc] = c + 1;
118
73
                ++argc;
119
74
            }
120
75
        }
121
76
        ++c;
122
77
    }
123
78
    argv[argc] = NULL;
124
79
    return execv(argv[0], argv);
125
80
}
126
81
127
82
FILE* popen_with_pid(char const* cmd, pid_t& pid)
128
83
{
129
84
    int pipefd[2];
130
85
    if (pipe(pipefd))
131
86
        return NULL;
132
87
133
88
    int const& pipe_out = pipefd[0];
134
89
    int const& pipe_in = pipefd[1];
135
90
136
91
    pid = fork();
137
92
    if (pid < 0)
138
93
    {
139
94
        close(pipe_in);
140
95
        close(pipe_out);
141
96
        return NULL;
142
97
    }
143
98
    else if (pid == 0)
144
99
    {
145
100
        close(pipe_out);
146
101
        dup2(pipe_in, 1);  // Child stdout goes into pipe_in
147
102
        close(pipe_in);
148
103
        exec_cmd(cmd);
149
104
        exit(errno);
150
105
    }
151
106
    else
152
107
    {
153
108
        close(pipe_in);
154
109
    }
155
110
156
111
    return fdopen(pipe_out, "r");
157
112
}
158
113
159
114
bool spawn_and_forget(char const* cmd)
160
115
{
161
116
    int pid = fork();
162
117
    if (pid == 0)
163
118
    {
164
119
        // Silence stdout/stderr
165
120
        close(1);
166
121
        close(2);
167
122
        exec_cmd(cmd);
168
123
        exit(errno);
169
124
    }
170
125
    return (pid > 0);
171
126
}
172
127
173
128
bool spawn_and_forget(std::string const& cmd)
174
129
{
175
130
    return spawn_and_forget(cmd.c_str());
176
131
}
177
132
178
133
bool wait_for_file(char const* path, std::chrono::seconds timeout)
179
134
{
180
135
    struct stat s;
181
136
    int count = 0, max = timeout.count();
182
137
    int ret;
183
138
    while ((ret = stat(path, &s)) < 0 && errno == ENOENT && count < max)
184
139
    {
185
140
        ++count;
186
141
        std::this_thread::sleep_for(1s);
187
142
    }
188
143
    return ret == 0;
189
144
}
190
145
191
146
struct CompositorPerformance : testing::Test
192
147
{
193
148
    void SetUp() override
194
149
    {
195
150
        compositor_fps = compositor_render_time = -1.0f;
196
151
197
152
        auto const mir_sock = "/tmp/mir_test_socket_"+std::to_string(getpid());
198
153
        auto const server_cmd =
199
154
            bin_dir+"/mir_demo_server --compositor-report=log -f "+mir_sock;
200
155
    
201
156
        server_output = popen_with_pid(server_cmd.c_str(), server_pid);
202
157
        ASSERT_TRUE(server_output) << server_cmd;
203
158
        ASSERT_TRUE(wait_for_file(mir_sock.c_str(), 5s)) << server_cmd;
204
159
        setenv("MIR_SOCKET", mir_sock.c_str(), 1);
205
160
    }
206
161
207
162
    void TearDown() override
208
163
    {
209
164
        kill_nicely(server_pid);
210
165
        fclose(server_output);
211
166
    }
212
167
213
168
    void spawn_clients(std::initializer_list<std::string> clients)
214
169
    {
215
170
        for (auto& client : clients)
216
171
        {
217
172
            spawn_and_forget(bin_dir+"/"+client);
218
173
            std::this_thread::sleep_for(100ms);
219
174
        }
220
175
    }
221
176
222
177
    void wait_for_server(std::chrono::seconds timeout)
223
178
    {
224
179
        pid_t pid = server_pid;
225
180
        std::thread killer([timeout,pid]()
226
181
        {
227
182
            std::this_thread::sleep_for(timeout);
228
183
            kill_nicely(pid);
229
184
        });
230
185
        killer.detach();
231
186
232
187
        char line[256];
233
188
        while (fgets(line, sizeof(line), server_output))
234
189
        {
235
190
            if (char const* perf = strstr(line, "averaged "))
236
191
            {
237
192
                float fps, render_time;
238
193
                if (2 == sscanf(perf, "averaged %f FPS, %f ms/frame",
239
194
                                &fps, &render_time))
240
195
                {
241
196
                    compositor_fps = fps;
242
197
                    compositor_render_time = render_time;
243
198
                }
244
199
            }
245
200
        }
246
201
    }
247
202
248
203
    std::string const bin_dir{mir_bin_dir()};
249
204
    pid_t server_pid = 0;
250
205
    FILE* server_output;
251
206
    float compositor_fps, compositor_render_time;
252
207
};
253
208
254
209
} // anonymous namespace
255
210
256
211
TEST_F(CompositorPerformance, regression_test_1563287)
257
212
{
258
213
    spawn_clients({"mir_demo_client_flicker",
259
214
                   "mir_demo_client_egltriangle -b0.5 -f",
260
215
                   "mir_demo_client_progressbar",
261
216
                   "mir_demo_client_scroll",
262
217
                   "mir_demo_client_egltriangle -b0.5",
263
218
                   "mir_demo_client_multiwin"});
264
219
    wait_for_server(10s);
265
220
    EXPECT_GE(compositor_fps, 58.0f);
266
221
    EXPECT_LT(compositor_render_time, 17.0f);
267
222
}
Status:	Merged
Approved by:	Daniel van Vugt on 2016-05-10
Approved revision:	no longer in the source branch.
Merged at revision:	3503
Proposed branch:	lp:~vanvugt/mir/compositor-test-in-c-minor
Merge into:	lp:mir
Diff against target:	267 lines (+232/-1) 4 files modified debian/mir-test-tools.install (+1/-0) tests/performance-tests/CMakeLists.txt (+7/-0) tests/performance-tests/performance_tests.sh (+2/-1) tests/performance-tests/test_compositor.cpp (+222/-0)
To merge this branch:	bzr merge lp:~vanvugt/mir/compositor-test-in-c-minor
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Mir CI Bot	continuous-integration		Approve on 2016-05-10
Kevin DuBois (community)		2016-05-06	Approve on 2016-05-09
Review via email: mp+293986@code.launchpad.net