]>
Commit | Line | Data |
---|---|---|
fb13bbf2 FZ |
1 | #!/usr/bin/env python |
2 | # | |
3 | # Tests for IO throttling | |
4 | # | |
5 | # Copyright (C) 2015 Red Hat, Inc. | |
2db33f88 | 6 | # Copyright (C) 2015 Igalia, S.L. |
fb13bbf2 FZ |
7 | # |
8 | # This program is free software; you can redistribute it and/or modify | |
9 | # it under the terms of the GNU General Public License as published by | |
10 | # the Free Software Foundation; either version 2 of the License, or | |
11 | # (at your option) any later version. | |
12 | # | |
13 | # This program is distributed in the hope that it will be useful, | |
14 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | # GNU General Public License for more details. | |
17 | # | |
18 | # You should have received a copy of the GNU General Public License | |
19 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
20 | # | |
21 | ||
22 | import iotests | |
23 | ||
24 | class ThrottleTestCase(iotests.QMPTestCase): | |
25 | test_img = "null-aio://" | |
2db33f88 | 26 | max_drives = 3 |
fb13bbf2 FZ |
27 | |
28 | def blockstats(self, device): | |
29 | result = self.vm.qmp("query-blockstats") | |
30 | for r in result['return']: | |
31 | if r['device'] == device: | |
32 | stat = r['stats'] | |
33 | return stat['rd_bytes'], stat['rd_operations'], stat['wr_bytes'], stat['wr_operations'] | |
34 | raise Exception("Device not found for blockstats: %s" % device) | |
35 | ||
36 | def setUp(self): | |
2db33f88 AG |
37 | self.vm = iotests.VM() |
38 | for i in range(0, self.max_drives): | |
39 | self.vm.add_drive(self.test_img) | |
fb13bbf2 FZ |
40 | self.vm.launch() |
41 | ||
42 | def tearDown(self): | |
43 | self.vm.shutdown() | |
44 | ||
2db33f88 | 45 | def do_test_throttle(self, ndrives, seconds, params): |
fb13bbf2 FZ |
46 | def check_limit(limit, num): |
47 | # IO throttling algorithm is discrete, allow 10% error so the test | |
48 | # is more robust | |
49 | return limit == 0 or \ | |
2db33f88 AG |
50 | (num < seconds * limit * 1.1 / ndrives |
51 | and num > seconds * limit * 0.9 / ndrives) | |
fb13bbf2 FZ |
52 | |
53 | nsec_per_sec = 1000000000 | |
54 | ||
2db33f88 | 55 | params['group'] = 'test' |
fb13bbf2 | 56 | |
2db33f88 AG |
57 | # Set the I/O throttling parameters to all drives |
58 | for i in range(0, ndrives): | |
59 | params['device'] = 'drive%d' % i | |
60 | result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **params) | |
61 | self.assert_qmp(result, 'return', {}) | |
fb13bbf2 FZ |
62 | |
63 | # Set vm clock to a known value | |
64 | ns = seconds * nsec_per_sec | |
65 | self.vm.qtest("clock_step %d" % ns) | |
66 | ||
67 | # Submit enough requests. They will drain bps_max and iops_max, but the | |
68 | # rest requests won't get executed until we advance the virtual clock | |
69 | # with qtest interface | |
70 | rq_size = 512 | |
71 | rd_nr = max(params['bps'] / rq_size / 2, | |
72 | params['bps_rd'] / rq_size, | |
73 | params['iops'] / 2, | |
74 | params['iops_rd']) | |
75 | rd_nr *= seconds * 2 | |
2db33f88 | 76 | rd_nr /= ndrives |
fb13bbf2 FZ |
77 | wr_nr = max(params['bps'] / rq_size / 2, |
78 | params['bps_wr'] / rq_size, | |
79 | params['iops'] / 2, | |
80 | params['iops_wr']) | |
81 | wr_nr *= seconds * 2 | |
2db33f88 AG |
82 | wr_nr /= ndrives |
83 | ||
84 | # Send I/O requests to all drives | |
fb13bbf2 | 85 | for i in range(rd_nr): |
2db33f88 AG |
86 | for drive in range(0, ndrives): |
87 | self.vm.hmp_qemu_io("drive%d" % drive, "aio_read %d %d" % | |
88 | (i * rq_size, rq_size)) | |
fb13bbf2 | 89 | |
2db33f88 AG |
90 | for i in range(wr_nr): |
91 | for drive in range(0, ndrives): | |
92 | self.vm.hmp_qemu_io("drive%d" % drive, "aio_write %d %d" % | |
93 | (i * rq_size, rq_size)) | |
94 | ||
95 | # We'll store the I/O stats for each drive in these arrays | |
96 | start_rd_bytes = [0] * ndrives | |
97 | start_rd_iops = [0] * ndrives | |
98 | start_wr_bytes = [0] * ndrives | |
99 | start_wr_iops = [0] * ndrives | |
100 | end_rd_bytes = [0] * ndrives | |
101 | end_rd_iops = [0] * ndrives | |
102 | end_wr_bytes = [0] * ndrives | |
103 | end_wr_iops = [0] * ndrives | |
104 | ||
105 | # Read the stats before advancing the clock | |
106 | for i in range(0, ndrives): | |
107 | start_rd_bytes[i], start_rd_iops[i], start_wr_bytes[i], \ | |
108 | start_wr_iops[i] = self.blockstats('drive%d' % i) | |
fb13bbf2 FZ |
109 | |
110 | self.vm.qtest("clock_step %d" % ns) | |
fb13bbf2 | 111 | |
2db33f88 AG |
112 | # Read the stats after advancing the clock |
113 | for i in range(0, ndrives): | |
114 | end_rd_bytes[i], end_rd_iops[i], end_wr_bytes[i], \ | |
115 | end_wr_iops[i] = self.blockstats('drive%d' % i) | |
116 | ||
117 | # Check that the I/O is within the limits and evenly distributed | |
118 | for i in range(0, ndrives): | |
119 | rd_bytes = end_rd_bytes[i] - start_rd_bytes[i] | |
120 | rd_iops = end_rd_iops[i] - start_rd_iops[i] | |
121 | wr_bytes = end_wr_bytes[i] - start_wr_bytes[i] | |
122 | wr_iops = end_wr_iops[i] - start_wr_iops[i] | |
123 | ||
124 | self.assertTrue(check_limit(params['bps'], rd_bytes + wr_bytes)) | |
125 | self.assertTrue(check_limit(params['bps_rd'], rd_bytes)) | |
126 | self.assertTrue(check_limit(params['bps_wr'], wr_bytes)) | |
127 | self.assertTrue(check_limit(params['iops'], rd_iops + wr_iops)) | |
128 | self.assertTrue(check_limit(params['iops_rd'], rd_iops)) | |
129 | self.assertTrue(check_limit(params['iops_wr'], wr_iops)) | |
fb13bbf2 FZ |
130 | |
131 | def test_all(self): | |
132 | params = {"bps": 4096, | |
133 | "bps_rd": 4096, | |
134 | "bps_wr": 4096, | |
135 | "iops": 10, | |
136 | "iops_rd": 10, | |
137 | "iops_wr": 10, | |
138 | } | |
2db33f88 AG |
139 | # Repeat the test with different numbers of drives |
140 | for ndrives in range(1, self.max_drives + 1): | |
141 | # Pick each out of all possible params and test | |
142 | for tk in params: | |
143 | limits = dict([(k, 0) for k in params]) | |
144 | limits[tk] = params[tk] * ndrives | |
145 | self.do_test_throttle(ndrives, 5, limits) | |
fb13bbf2 FZ |
146 | |
147 | class ThrottleTestCoroutine(ThrottleTestCase): | |
148 | test_img = "null-co://" | |
149 | ||
150 | if __name__ == '__main__': | |
151 | iotests.main(supported_fmts=["raw"]) |