| Message ID | 1391769813-15437-6-git-send-email-famz@redhat.com |
|---|---|
| State | New |
| Headers | show |
Le Friday 07 Feb 2014 à 18:43:33 (+0800), Fam Zheng a écrit : > This case utilizes qemu-io command "aio_{read,write} -q" to verify the > effectiveness of IO throttling options. > > It's implemented by driving the vm timer from qtest protocol, so the > throttling timers are signaled with determined time duration. Then we > verify the completed IO requests are within 110% of bps and iops limits. > > Signed-off-by: Fam Zheng <famz@redhat.com> > --- > tests/qemu-iotests/080 | 172 +++++++++++++++++++++++++++++++++++++++++++++ > tests/qemu-iotests/080.out | 5 ++ > tests/qemu-iotests/group | 1 + > 3 files changed, 178 insertions(+) > create mode 100755 tests/qemu-iotests/080 > create mode 100644 tests/qemu-iotests/080.out > > diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 > new file mode 100755 > index 0000000..32983f0 > --- /dev/null > +++ b/tests/qemu-iotests/080 > @@ -0,0 +1,172 @@ > +#!/usr/bin/env python > +# > +# Tests for IO throttling > +# > +# Copyright (C) 2014 Red Hat, Inc. > +# > +# This program is free software; you can redistribute it and/or modify > +# it under the terms of the GNU General Public License as published by > +# the Free Software Foundation; either version 2 of the License, or > +# (at your option) any later version. > +# > +# This program is distributed in the hope that it will be useful, > +# but WITHOUT ANY WARRANTY; without even the implied warranty of > +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > +# GNU General Public License for more details. > +# > +# You should have received a copy of the GNU General Public License > +# along with this program. If not, see <http://www.gnu.org/licenses/>. > +# > + > +import time > +import os > +import iotests > +from iotests import qemu_img > + > +test_img = os.path.join(iotests.test_dir, 'test.img') > + > +class ThrottleTestCase(iotests.QMPTestCase): > + image_len = 80 * 1024 * 1024 # MB image_len is defined here but not used anywhere. > + > + def blockstats(self, device): > + result = self.vm.qmp("query-blockstats") > + for r in result['return']: > + if r['device'] == device: > + stat = r['stats'] > + return stat['rd_bytes'], stat['rd_operations'], stat['wr_bytes'], stat['wr_operations'] > + raise Exception("Device not found for blockstats: %s" % device) > + > + def setUp(self): > + qemu_img('create', '-f', iotests.imgfmt, test_img, "1G") > + self.vm = iotests.VM().add_drive(test_img) > + self.vm.launch() > + > + def tearDown(self): > + self.vm.shutdown() > + os.remove(test_img) > + > + def do_test_throttle(self, seconds=10, **limits): > + def check_limit(limit, num): > + # IO throttling algorithm is discrete, allow 10% error so the test > + # is more deterministic > + return limit == 0 or num <= seconds * limit * 1.1 Maybe the code should also test for seconds * limit * 0.9 <= num. > + > + nsec_per_sec = 1000000000 > + > + # With current interface we can't set burst to 0, they will be override > + # to bps / 10 and iops / 10. Setting to 1 workarounds this and gets to > + # a close effect as no burst, which is good enough for us > + limits['bps_max'] = 1 > + limits['iops_max'] = 1 Maybe the code should also set *rd_max = 1 and *wr_max= 1 to make the *_rd_* and *_wr_* tests more accurate. > + > + # Enqueue many requests to throttling queue This comment looks wrong the code is defining the throttling limits: " # Define the throttling limits" > + result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **limits) > + self.assert_qmp(result, 'return', {}) > + > + # Set vm clock to a known value > + ns = nsec_per_sec > + self.vm.qtest("clock_step %d" % ns) > + > + # Append many requests into the throttle queue > + # They drain bps_max and iops_max > + # The rest requests won't get executed until qtest clock is driven s/The rest requests/The remaining requests/g > + for i in range(100): > + self.vm.hmp_qemu_io("drive0", "aio_read -q 0 512") > + self.vm.hmp_qemu_io("drive0", "aio_write -q 0 512") > + > + start_rd_bytes, start_rd_iops, start_wr_bytes, start_wr_iops = self.blockstats('drive0') > + > + ns += seconds * nsec_per_sec > + self.vm.qtest("clock_step %d" % ns) > + # wait for a while to let requests take off > + time.sleep(1) > + end_rd_bytes, end_rd_iops, end_wr_bytes, end_wr_iops = self.blockstats('drive0') > + > + # Read and write requests should be processed > + assert end_rd_bytes > 0 > + assert end_rd_iops > 0 > + assert end_wr_bytes > 0 > + assert end_wr_iops > 0 > + > + rd_bytes = end_rd_bytes - start_rd_bytes > + rd_iops = end_rd_iops - start_rd_iops > + wr_bytes = end_wr_bytes - start_wr_bytes > + wr_iops = end_wr_iops - start_wr_iops > + > + assert check_limit(limits['bps'], rd_bytes) > + assert check_limit(limits['bps_rd'], rd_bytes) > + assert check_limit(limits['bps'], wr_bytes) > + assert check_limit(limits['bps_wr'], wr_bytes) > + assert check_limit(limits['iops'], rd_iops) > + assert check_limit(limits['iops_rd'], rd_iops) > + assert check_limit(limits['iops'], wr_iops) > + assert check_limit(limits['iops_wr'], wr_iops) > + > + def test_bps(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 1024, > + 'bps_rd': 0, > + 'bps_wr': 0, > + 'iops': 0, > + 'iops_rd': 0, > + 'iops_wr': 0, > + }) > + > + def test_bps_rd(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 0, > + 'bps_rd': 1024, > + 'bps_wr': 0, > + 'iops': 0, > + 'iops_rd': 0, > + 'iops_wr': 0, > + }) > + > + def test_bps_wr(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 0, > + 'bps_rd': 0, > + 'bps_wr': 1024, > + 'iops': 0, > + 'iops_rd': 0, > + 'iops_wr': 0, > + }) > + > + def test_iops(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 0, > + 'bps_rd': 0, > + 'bps_wr': 0, > + 'iops': 10, > + 'iops_rd': 0, > + 'iops_wr': 0, > + }) > + > + def test_iops_rd(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 0, > + 'bps_rd': 0, > + 'bps_wr': 0, > + 'iops': 0, > + 'iops_rd': 10, > + 'iops_wr': 0, > + }) > + > + def test_iops_wr(self): > + self.do_test_throttle(**{ > + 'device': 'drive0', > + 'bps': 0, > + 'bps_rd': 0, > + 'bps_wr': 0, > + 'iops': 0, > + 'iops_rd': 0, > + 'iops_wr': 10, > + }) > + > +if __name__ == '__main__': > + iotests.main() > diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out > new file mode 100644 > index 0000000..3f8a935 > --- /dev/null > +++ b/tests/qemu-iotests/080.out > @@ -0,0 +1,5 @@ > +...... > +---------------------------------------------------------------------- > +Ran 6 tests > + > +OK > diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group > index 03c762f..013a7ef 100644 > --- a/tests/qemu-iotests/group > +++ b/tests/qemu-iotests/group > @@ -82,3 +82,4 @@ > 073 rw auto > 074 rw auto > 077 rw auto > +080 rw auto > -- > 1.8.5.4 >
On Mon, 02/10 13:32, Benoît Canet wrote: > Le Friday 07 Feb 2014 à 18:43:33 (+0800), Fam Zheng a écrit : > > + nsec_per_sec = 1000000000 > > + > > + # With current interface we can't set burst to 0, they will be override > > + # to bps / 10 and iops / 10. Setting to 1 workarounds this and gets to > > + # a close effect as no burst, which is good enough for us > > + limits['bps_max'] = 1 > > + limits['iops_max'] = 1 > Maybe the code should also set *rd_max = 1 and *wr_max= 1 to make the *_rd_* and > *_wr_* tests more accurate. The code doesn't allow setting bps_rd_max together with bps_max. I think bps_max has enough effective on burst, so it's not strictly necessary. Fam
diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080 new file mode 100755 index 0000000..32983f0 --- /dev/null +++ b/tests/qemu-iotests/080 @@ -0,0 +1,172 @@ +#!/usr/bin/env python +# +# Tests for IO throttling +# +# Copyright (C) 2014 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +import time +import os +import iotests +from iotests import qemu_img + +test_img = os.path.join(iotests.test_dir, 'test.img') + +class ThrottleTestCase(iotests.QMPTestCase): + image_len = 80 * 1024 * 1024 # MB + + def blockstats(self, device): + result = self.vm.qmp("query-blockstats") + for r in result['return']: + if r['device'] == device: + stat = r['stats'] + return stat['rd_bytes'], stat['rd_operations'], stat['wr_bytes'], stat['wr_operations'] + raise Exception("Device not found for blockstats: %s" % device) + + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, test_img, "1G") + self.vm = iotests.VM().add_drive(test_img) + self.vm.launch() + + def tearDown(self): + self.vm.shutdown() + os.remove(test_img) + + def do_test_throttle(self, seconds=10, **limits): + def check_limit(limit, num): + # IO throttling algorithm is discrete, allow 10% error so the test + # is more deterministic + return limit == 0 or num <= seconds * limit * 1.1 + + nsec_per_sec = 1000000000 + + # With current interface we can't set burst to 0, they will be override + # to bps / 10 and iops / 10. Setting to 1 workarounds this and gets to + # a close effect as no burst, which is good enough for us + limits['bps_max'] = 1 + limits['iops_max'] = 1 + + # Enqueue many requests to throttling queue + result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **limits) + self.assert_qmp(result, 'return', {}) + + # Set vm clock to a known value + ns = nsec_per_sec + self.vm.qtest("clock_step %d" % ns) + + # Append many requests into the throttle queue + # They drain bps_max and iops_max + # The rest requests won't get executed until qtest clock is driven + for i in range(100): + self.vm.hmp_qemu_io("drive0", "aio_read -q 0 512") + self.vm.hmp_qemu_io("drive0", "aio_write -q 0 512") + + start_rd_bytes, start_rd_iops, start_wr_bytes, start_wr_iops = self.blockstats('drive0') + + ns += seconds * nsec_per_sec + self.vm.qtest("clock_step %d" % ns) + # wait for a while to let requests take off + time.sleep(1) + end_rd_bytes, end_rd_iops, end_wr_bytes, end_wr_iops = self.blockstats('drive0') + + # Read and write requests should be processed + assert end_rd_bytes > 0 + assert end_rd_iops > 0 + assert end_wr_bytes > 0 + assert end_wr_iops > 0 + + rd_bytes = end_rd_bytes - start_rd_bytes + rd_iops = end_rd_iops - start_rd_iops + wr_bytes = end_wr_bytes - start_wr_bytes + wr_iops = end_wr_iops - start_wr_iops + + assert check_limit(limits['bps'], rd_bytes) + assert check_limit(limits['bps_rd'], rd_bytes) + assert check_limit(limits['bps'], wr_bytes) + assert check_limit(limits['bps_wr'], wr_bytes) + assert check_limit(limits['iops'], rd_iops) + assert check_limit(limits['iops_rd'], rd_iops) + assert check_limit(limits['iops'], wr_iops) + assert check_limit(limits['iops_wr'], wr_iops) + + def test_bps(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 1024, + 'bps_rd': 0, + 'bps_wr': 0, + 'iops': 0, + 'iops_rd': 0, + 'iops_wr': 0, + }) + + def test_bps_rd(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 0, + 'bps_rd': 1024, + 'bps_wr': 0, + 'iops': 0, + 'iops_rd': 0, + 'iops_wr': 0, + }) + + def test_bps_wr(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 0, + 'bps_rd': 0, + 'bps_wr': 1024, + 'iops': 0, + 'iops_rd': 0, + 'iops_wr': 0, + }) + + def test_iops(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 0, + 'bps_rd': 0, + 'bps_wr': 0, + 'iops': 10, + 'iops_rd': 0, + 'iops_wr': 0, + }) + + def test_iops_rd(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 0, + 'bps_rd': 0, + 'bps_wr': 0, + 'iops': 0, + 'iops_rd': 10, + 'iops_wr': 0, + }) + + def test_iops_wr(self): + self.do_test_throttle(**{ + 'device': 'drive0', + 'bps': 0, + 'bps_rd': 0, + 'bps_wr': 0, + 'iops': 0, + 'iops_rd': 0, + 'iops_wr': 10, + }) + +if __name__ == '__main__': + iotests.main() diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out new file mode 100644 index 0000000..3f8a935 --- /dev/null +++ b/tests/qemu-iotests/080.out @@ -0,0 +1,5 @@ +...... +---------------------------------------------------------------------- +Ran 6 tests + +OK diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group index 03c762f..013a7ef 100644 --- a/tests/qemu-iotests/group +++ b/tests/qemu-iotests/group @@ -82,3 +82,4 @@ 073 rw auto 074 rw auto 077 rw auto +080 rw auto
This case utilizes qemu-io command "aio_{read,write} -q" to verify the effectiveness of IO throttling options. It's implemented by driving the vm timer from qtest protocol, so the throttling timers are signaled with determined time duration. Then we verify the completed IO requests are within 110% of bps and iops limits. Signed-off-by: Fam Zheng <famz@redhat.com> --- tests/qemu-iotests/080 | 172 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/080.out | 5 ++ tests/qemu-iotests/group | 1 + 3 files changed, 178 insertions(+) create mode 100755 tests/qemu-iotests/080 create mode 100644 tests/qemu-iotests/080.out