| Message ID | 20200217150246.29180-17-vsementsov@virtuozzo.com |
|---|---|
| State | New |
| Headers | show |
| Series | Fix error handling during bitmap postcopy | expand |
On 17/02/2020 18:02, Vladimir Sementsov-Ogievskiy wrote: > iotest 40 works too long because of many discard opertion. On the same operations At the same time > time, postcopy period is very short, in spite of all these efforts. > > So, let's use less discards (and with more interesting patterns) to > reduce test timing. In the next commit we'll increase postcopy period. > > Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> > --- > tests/qemu-iotests/199 | 44 +++++++++++++++++++++++++----------------- > 1 file changed, 26 insertions(+), 18 deletions(-) > > diff --git a/tests/qemu-iotests/199 b/tests/qemu-iotests/199 > index d78f81b71c..7914fd0b2b 100755 > --- a/tests/qemu-iotests/199 > +++ b/tests/qemu-iotests/199 > @@ -30,6 +30,28 @@ size = '256G' > fifo = os.path.join(iotests.test_dir, 'mig_fifo') > > > +GiB = 1024 * 1024 * 1024 > + > +discards1 = ( > + (0, GiB), > + (2 * GiB + 512 * 5, 512), > + (3 * GiB + 512 * 5, 512), > + (100 * GiB, GiB) > +) > + > +discards2 = ( > + (3 * GiB + 512 * 8, 512), > + (4 * GiB + 512 * 8, 512), > + (50 * GiB, GiB), > + (100 * GiB + GiB // 2, GiB) > +) > + > + > +def apply_discards(vm, discards): > + for d in discards: If we run qemu-io only once, it will update the bitmap state and will speed the test performance up. Is that wrong idea? > + vm.hmp_qemu_io('drive0', 'discard {} {}'.format(*d)) > + > + > def event_seconds(event): > return event['timestamp']['seconds'] + \ > event['timestamp']['microseconds'] / 1000000.0 > @@ -80,9 +102,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): > self.vm_b_events = [] > > def test_postcopy(self): > - discard_size = 0x40000000 > granularity = 512 > - chunk = 4096 > > result = self.vm_a.qmp('block-dirty-bitmap-add', node='drive0', > name='bitmap', granularity=granularity) > @@ -92,14 +112,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): > node='drive0', name='bitmap') > empty_sha256 = result['return']['sha256'] > > - s = 0 > - while s < discard_size: > - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) > - s += 0x10000 > - s = 0x8000 > - while s < discard_size: > - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) > - s += 0x10000 > + apply_discards(self.vm_a, discards1 + discards2) > > result = self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256', > node='drive0', name='bitmap') > @@ -111,10 +124,8 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): > result = self.vm_a.qmp('block-dirty-bitmap-clear', node='drive0', > name='bitmap') > self.assert_qmp(result, 'return', {}) > - s = 0 > - while s < discard_size: > - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) > - s += 0x10000 > + > + apply_discards(self.vm_a, discards1) > > caps = [{'capability': 'dirty-bitmaps', 'state': True}, > {'capability': 'events', 'state': True}] > @@ -134,10 +145,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): > e_resume = self.vm_b.event_wait('RESUME') > self.vm_b_events.append(e_resume) > > - s = 0x8000 > - while s < discard_size: > - self.vm_b.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) > - s += 0x10000 > + apply_discards(self.vm_b, discards2) > > match = {'data': {'status': 'completed'}} > e_complete = self.vm_b.event_wait('MIGRATION', match=match) > Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
On 19/02/2020 17:33, Andrey Shinkevich wrote: > On 17/02/2020 18:02, Vladimir Sementsov-Ogievskiy wrote: >> iotest 40 works too long because of many discard opertion. On the same > > operations > At the same time > >> time, postcopy period is very short, in spite of all these efforts. >> >> So, let's use less discards (and with more interesting patterns) to >> reduce test timing. In the next commit we'll increase postcopy period. >> >> Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> >> --- >> tests/qemu-iotests/199 | 44 +++++++++++++++++++++++++----------------- >> 1 file changed, 26 insertions(+), 18 deletions(-) >> >> diff --git a/tests/qemu-iotests/199 b/tests/qemu-iotests/199 >> index d78f81b71c..7914fd0b2b 100755 >> --- a/tests/qemu-iotests/199 >> +++ b/tests/qemu-iotests/199 >> @@ -30,6 +30,28 @@ size = '256G' >> fifo = os.path.join(iotests.test_dir, 'mig_fifo') >> +GiB = 1024 * 1024 * 1024 >> + >> +discards1 = ( >> + (0, GiB), >> + (2 * GiB + 512 * 5, 512), >> + (3 * GiB + 512 * 5, 512), >> + (100 * GiB, GiB) >> +) >> + >> +discards2 = ( >> + (3 * GiB + 512 * 8, 512), >> + (4 * GiB + 512 * 8, 512), >> + (50 * GiB, GiB), >> + (100 * GiB + GiB // 2, GiB) >> +) >> + >> + >> +def apply_discards(vm, discards): >> + for d in discards: > > If we run qemu-io only once, it will update the bitmap state and will > speed the test performance up. Is that wrong idea? Yes, that is. I have seen with the later review. Andrey > >> + vm.hmp_qemu_io('drive0', 'discard {} {}'.format(*d)) >> + >> + >> def event_seconds(event): >> return event['timestamp']['seconds'] + \ >> event['timestamp']['microseconds'] / 1000000.0 >> @@ -80,9 +102,7 @@ class >> TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> self.vm_b_events = [] >> def test_postcopy(self): >> - discard_size = 0x40000000 >> granularity = 512 >> - chunk = 4096 >> result = self.vm_a.qmp('block-dirty-bitmap-add', node='drive0', >> name='bitmap', granularity=granularity) >> @@ -92,14 +112,7 @@ class >> TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> node='drive0', name='bitmap') >> empty_sha256 = result['return']['sha256'] >> - s = 0 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, >> chunk)) >> - s += 0x10000 >> - s = 0x8000 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, >> chunk)) >> - s += 0x10000 >> + apply_discards(self.vm_a, discards1 + discards2) >> result = self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256', >> node='drive0', name='bitmap') >> @@ -111,10 +124,8 @@ class >> TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> result = self.vm_a.qmp('block-dirty-bitmap-clear', >> node='drive0', >> name='bitmap') >> self.assert_qmp(result, 'return', {}) >> - s = 0 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, >> chunk)) >> - s += 0x10000 >> + >> + apply_discards(self.vm_a, discards1) >> caps = [{'capability': 'dirty-bitmaps', 'state': True}, >> {'capability': 'events', 'state': True}] >> @@ -134,10 +145,7 @@ class >> TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> e_resume = self.vm_b.event_wait('RESUME') >> self.vm_b_events.append(e_resume) >> - s = 0x8000 >> - while s < discard_size: >> - self.vm_b.hmp_qemu_io('drive0', 'discard %d %d' % (s, >> chunk)) >> - s += 0x10000 >> + apply_discards(self.vm_b, discards2) >> match = {'data': {'status': 'completed'}} >> e_complete = self.vm_b.event_wait('MIGRATION', match=match) >> > > Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
19.02.2020 17:33, Andrey Shinkevich wrote: > On 17/02/2020 18:02, Vladimir Sementsov-Ogievskiy wrote: >> iotest 40 works too long because of many discard opertion. On the same > > operations > At the same time > >> time, postcopy period is very short, in spite of all these efforts. >> >> So, let's use less discards (and with more interesting patterns) to >> reduce test timing. In the next commit we'll increase postcopy period. >> >> Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> >> --- >> tests/qemu-iotests/199 | 44 +++++++++++++++++++++++++----------------- >> 1 file changed, 26 insertions(+), 18 deletions(-) >> >> diff --git a/tests/qemu-iotests/199 b/tests/qemu-iotests/199 >> index d78f81b71c..7914fd0b2b 100755 >> --- a/tests/qemu-iotests/199 >> +++ b/tests/qemu-iotests/199 >> @@ -30,6 +30,28 @@ size = '256G' >> fifo = os.path.join(iotests.test_dir, 'mig_fifo') >> +GiB = 1024 * 1024 * 1024 >> + >> +discards1 = ( >> + (0, GiB), >> + (2 * GiB + 512 * 5, 512), >> + (3 * GiB + 512 * 5, 512), >> + (100 * GiB, GiB) >> +) >> + >> +discards2 = ( >> + (3 * GiB + 512 * 8, 512), >> + (4 * GiB + 512 * 8, 512), >> + (50 * GiB, GiB), >> + (100 * GiB + GiB // 2, GiB) >> +) >> + >> + >> +def apply_discards(vm, discards): >> + for d in discards: > > If we run qemu-io only once, it will update the bitmap state and will speed the test performance up. Is that wrong idea? But it will be less interesting test. Now we have several regions, which are in different relations in discards1 and discards2. And four elements are handled fast enough. > >> + vm.hmp_qemu_io('drive0', 'discard {} {}'.format(*d)) >> + >> + >> def event_seconds(event): >> return event['timestamp']['seconds'] + \ >> event['timestamp']['microseconds'] / 1000000.0 >> @@ -80,9 +102,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> self.vm_b_events = [] >> def test_postcopy(self): >> - discard_size = 0x40000000 >> granularity = 512 >> - chunk = 4096 >> result = self.vm_a.qmp('block-dirty-bitmap-add', node='drive0', >> name='bitmap', granularity=granularity) >> @@ -92,14 +112,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> node='drive0', name='bitmap') >> empty_sha256 = result['return']['sha256'] >> - s = 0 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) >> - s += 0x10000 >> - s = 0x8000 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) >> - s += 0x10000 >> + apply_discards(self.vm_a, discards1 + discards2) >> result = self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256', >> node='drive0', name='bitmap') >> @@ -111,10 +124,8 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> result = self.vm_a.qmp('block-dirty-bitmap-clear', node='drive0', >> name='bitmap') >> self.assert_qmp(result, 'return', {}) >> - s = 0 >> - while s < discard_size: >> - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) >> - s += 0x10000 >> + >> + apply_discards(self.vm_a, discards1) >> caps = [{'capability': 'dirty-bitmaps', 'state': True}, >> {'capability': 'events', 'state': True}] >> @@ -134,10 +145,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): >> e_resume = self.vm_b.event_wait('RESUME') >> self.vm_b_events.append(e_resume) >> - s = 0x8000 >> - while s < discard_size: >> - self.vm_b.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) >> - s += 0x10000 >> + apply_discards(self.vm_b, discards2) >> match = {'data': {'status': 'completed'}} >> e_complete = self.vm_b.event_wait('MIGRATION', match=match) >> > > Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
On 2/17/20 9:02 AM, Vladimir Sementsov-Ogievskiy wrote: > iotest 40 works too long because of many discard opertion. On the same I'm assuming you meant s/40/199/ here, as well as the typo fixes pointed out by Andrey. > time, postcopy period is very short, in spite of all these efforts. > > So, let's use less discards (and with more interesting patterns) to > reduce test timing. In the next commit we'll increase postcopy period. > > Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> > --- > tests/qemu-iotests/199 | 44 +++++++++++++++++++++++++----------------- > 1 file changed, 26 insertions(+), 18 deletions(-) >
diff --git a/tests/qemu-iotests/199 b/tests/qemu-iotests/199 index d78f81b71c..7914fd0b2b 100755 --- a/tests/qemu-iotests/199 +++ b/tests/qemu-iotests/199 @@ -30,6 +30,28 @@ size = '256G' fifo = os.path.join(iotests.test_dir, 'mig_fifo') +GiB = 1024 * 1024 * 1024 + +discards1 = ( + (0, GiB), + (2 * GiB + 512 * 5, 512), + (3 * GiB + 512 * 5, 512), + (100 * GiB, GiB) +) + +discards2 = ( + (3 * GiB + 512 * 8, 512), + (4 * GiB + 512 * 8, 512), + (50 * GiB, GiB), + (100 * GiB + GiB // 2, GiB) +) + + +def apply_discards(vm, discards): + for d in discards: + vm.hmp_qemu_io('drive0', 'discard {} {}'.format(*d)) + + def event_seconds(event): return event['timestamp']['seconds'] + \ event['timestamp']['microseconds'] / 1000000.0 @@ -80,9 +102,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): self.vm_b_events = [] def test_postcopy(self): - discard_size = 0x40000000 granularity = 512 - chunk = 4096 result = self.vm_a.qmp('block-dirty-bitmap-add', node='drive0', name='bitmap', granularity=granularity) @@ -92,14 +112,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): node='drive0', name='bitmap') empty_sha256 = result['return']['sha256'] - s = 0 - while s < discard_size: - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) - s += 0x10000 - s = 0x8000 - while s < discard_size: - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) - s += 0x10000 + apply_discards(self.vm_a, discards1 + discards2) result = self.vm_a.qmp('x-debug-block-dirty-bitmap-sha256', node='drive0', name='bitmap') @@ -111,10 +124,8 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): result = self.vm_a.qmp('block-dirty-bitmap-clear', node='drive0', name='bitmap') self.assert_qmp(result, 'return', {}) - s = 0 - while s < discard_size: - self.vm_a.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) - s += 0x10000 + + apply_discards(self.vm_a, discards1) caps = [{'capability': 'dirty-bitmaps', 'state': True}, {'capability': 'events', 'state': True}] @@ -134,10 +145,7 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase): e_resume = self.vm_b.event_wait('RESUME') self.vm_b_events.append(e_resume) - s = 0x8000 - while s < discard_size: - self.vm_b.hmp_qemu_io('drive0', 'discard %d %d' % (s, chunk)) - s += 0x10000 + apply_discards(self.vm_b, discards2) match = {'data': {'status': 'completed'}} e_complete = self.vm_b.event_wait('MIGRATION', match=match)
iotest 40 works too long because of many discard opertion. On the same time, postcopy period is very short, in spite of all these efforts. So, let's use less discards (and with more interesting patterns) to reduce test timing. In the next commit we'll increase postcopy period. Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com> --- tests/qemu-iotests/199 | 44 +++++++++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 18 deletions(-)