mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

qemu-iotests/199: better catch postcopy time

Browse Source 
The test aims to test _postcopy_ migration, and wants to do some write
operations during postcopy time.

Test considers migrate status=complete event on source as start of
postcopy. This is completely wrong, completion is completion of the
whole migration process. Let's instead consider destination start as
start of postcopy, and use RESUME event for it.

Next, as migration finish, let's use migration status=complete event on
target, as such method is closer to what libvirt or another user will
do, than tracking number of dirty-bitmaps.

Finally, add a possibility to dump events for debug. And if
set debug to True, we see, that actual postcopy period is very small
relatively to the whole test duration time (~0.2 seconds to >40 seconds
for me). This means, that test is very inefficient in what it supposed
to do. Let's improve it in following commits.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Tested-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200727194236.19551-4-vsementsov@virtuozzo.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
This commit is contained in:
Vladimir Sementsov-Ogievskiy 2020-07-27 22:42:18 +03:00 committed by Eric Blake
parent f3f483ac63
commit 09feea6cf5
1 changed files with 58 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
tests/qemu-iotests/199
View File

@ -20,17 +20,43 @@
import os
import iotests
import time
from iotests import qemu_img
debug = False
disk_a = os.path.join(iotests.test_dir, 'disk_a')
disk_b = os.path.join(iotests.test_dir, 'disk_b')
size = '256G'
fifo = os.path.join(iotests.test_dir, 'mig_fifo')
def event_seconds(event):
return event['timestamp']['seconds'] + \
event['timestamp']['microseconds'] / 1000000.0
def event_dist(e1, e2):
return event_seconds(e2) - event_seconds(e1)
class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase):
def tearDown(self):
if debug:
self.vm_a_events += self.vm_a.get_qmp_events()
self.vm_b_events += self.vm_b.get_qmp_events()
for e in self.vm_a_events:
e['vm'] = 'SRC'
for e in self.vm_b_events:
e['vm'] = 'DST'
events = (self.vm_a_events + self.vm_b_events)
events = [(e['timestamp']['seconds'],
e['timestamp']['microseconds'],
e['vm'],
e['event'],
e.get('data', '')) for e in events]
for e in sorted(events):
print('{}.{:06} {} {} {}'.format(*e))
self.vm_a.shutdown()
self.vm_b.shutdown()
os.remove(disk_a)
@ -47,6 +73,10 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase):
self.vm_a.launch()
self.vm_b.launch()
# collect received events for debug
self.vm_a_events = []
self.vm_b_events = []
def test_postcopy(self):
write_size = 0x40000000
granularity = 512
@ -77,15 +107,13 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase):
self.vm_a.hmp_qemu_io('drive0', 'write %d %d' % (s, chunk))
s += 0x10000
bitmaps_cap = {'capability': 'dirty-bitmaps', 'state': True}
events_cap = {'capability': 'events', 'state': True}
caps = [{'capability': 'dirty-bitmaps', 'state': True},
{'capability': 'events', 'state': True}]
result = self.vm_a.qmp('migrate-set-capabilities',
capabilities=[bitmaps_cap, events_cap])
result = self.vm_a.qmp('migrate-set-capabilities', capabilities=caps)
self.assert_qmp(result, 'return', {})
result = self.vm_b.qmp('migrate-set-capabilities',
capabilities=[bitmaps_cap])
result = self.vm_b.qmp('migrate-set-capabilities', capabilities=caps)
self.assert_qmp(result, 'return', {})
result = self.vm_a.qmp('migrate', uri='exec:cat>' + fifo)
@ -94,24 +122,38 @@ class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase):
result = self.vm_a.qmp('migrate-start-postcopy')
self.assert_qmp(result, 'return', {})
while True:
event = self.vm_a.event_wait('MIGRATION')
if event['data']['status'] == 'completed':
break
event_resume = self.vm_b.event_wait('RESUME')
self.vm_b_events.append(event_resume)
s = 0x8000
while s < write_size:
self.vm_b.hmp_qemu_io('drive0', 'write %d %d' % (s, chunk))
s += 0x10000
result = self.vm_b.qmp('query-block')
while len(result['return'][0]['dirty-bitmaps']) > 1:
time.sleep(2)
result = self.vm_b.qmp('query-block')
match = {'data': {'status': 'completed'}}
event_complete = self.vm_b.event_wait('MIGRATION', match=match)
self.vm_b_events.append(event_complete)
# take queued event, should already been happened
event_stop = self.vm_a.event_wait('STOP')
self.vm_a_events.append(event_stop)
downtime = event_dist(event_stop, event_resume)
postcopy_time = event_dist(event_resume, event_complete)
# TODO: assert downtime * 10 < postcopy_time
if debug:
print('downtime:', downtime)
print('postcopy_time:', postcopy_time)
# Assert that bitmap migration is finished (check that successor bitmap
# is removed)
result = self.vm_b.qmp('query-block')
assert len(result['return'][0]['dirty-bitmaps']) == 1
# Check content of migrated (and updated by new writes) bitmap
result = self.vm_b.qmp('x-debug-block-dirty-bitmap-sha256',
node='drive0', name='bitmap')
self.assert_qmp(result, 'return/sha256', sha256)