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(-)
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)
--
2.21.0
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(-) > -- Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
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>
--
With the best regards,
Andrey Shinkevich
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>
--
Best regards,
Vladimir
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>
--
With the best regards,
Andrey Shinkevich
© 2016 - 2026 Red Hat, Inc.