| Message ID | 1599661096-127913-12-git-send-email-zhengchuan@huawei.com |
|---|---|
| State | New |
| Headers | show |
| Series | *** A Method for evaluating dirty page rate *** | expand |
Chuan Zheng <zhengchuan@huawei.com> 于2020年9月9日周三 下午10:14写道： > > Implement qmp_cal_dirty_rate()/qmp_get_dirty_rate() function which could be called > > Signed-off-by: Chuan Zheng <zhengchuan@huawei.com> > --- > migration/dirtyrate.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++ > qapi/migration.json | 50 +++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 112 insertions(+) > > diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c > index 2f9ac34..e9e9e35 100644 > --- a/migration/dirtyrate.c > +++ b/migration/dirtyrate.c > @@ -61,6 +61,24 @@ static int dirtyrate_set_state(int *state, int old_state, int new_state) > } > } > > +static struct DirtyRateInfo *query_dirty_rate_info(void) > +{ > + int64_t dirty_rate = DirtyStat.dirty_rate; > + struct DirtyRateInfo *info = g_malloc0(sizeof(DirtyRateInfo)); > + > + if (CalculatingState == DIRTY_RATE_STATUS_MEASURED) { Should we use atomic read 'CalculatingState'? The qmp thread maybe run with the sampled thread. > + info->dirty_rate = dirty_rate; > + } else { > + info->dirty_rate = -1; > + } > + > + info->status = CalculatingState; > + info->start_time = DirtyStat.start_time; > + info->calc_time = DirtyStat.calc_time; > + > + return info; > +} > + > static void reset_dirtyrate_stat(void) > { > DirtyStat.total_dirty_samples = 0; > @@ -331,6 +349,8 @@ static void calculate_dirtyrate(struct DirtyRateConfig config) > > msec = config.sample_period_seconds * 1000; > msec = set_sample_page_period(msec, initial_time); > + DirtyStat.start_time = initial_time / 1000; > + DirtyStat.calc_time = msec / 1000; > > rcu_read_lock(); > if (compare_page_hash_info(block_dinfo, block_index) < 0) { > @@ -362,3 +382,45 @@ void *get_dirtyrate_thread(void *arg) > DIRTY_RATE_STATUS_MEASURED); > return NULL; > } > + > +void qmp_calc_dirty_rate(int64_t calc_time, Error **errp) > +{ > + static struct DirtyRateConfig config; > + QemuThread thread; > + int ret; > + > + /* > + * If the dirty rate is already being measured, don't attempt to start. > + */ > + if (CalculatingState == DIRTY_RATE_STATUS_MEASURING) { atomic read? > + error_setg(errp, "the dirty rate is already being measured."); > + return; > + } > + > + if (!get_sample_page_period(calc_time)) { > + error_setg(errp, "calc-time is out of range[%d, %d].", > + MIN_FETCH_DIRTYRATE_TIME_SEC, > + MAX_FETCH_DIRTYRATE_TIME_SEC); > + return; > + } > + > + /* > + * Init calculation state as unstarted. > + */ > + ret = dirtyrate_set_state(&CalculatingState, CalculatingState, > + DIRTY_RATE_STATUS_UNSTARTED); > + if (ret == -1) { > + error_setg(errp, "init dirty rate calculation state failed."); > + return; > + } > + > + config.sample_period_seconds = calc_time; > + config.sample_pages_per_gigabytes = DIRTYRATE_DEFAULT_SAMPLE_PAGES; > + qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, > + (void *)&config, QEMU_THREAD_DETACHED); > +} > + > +struct DirtyRateInfo *qmp_query_dirty_rate(Error **errp) > +{ > + return query_dirty_rate_info(); > +} > diff --git a/qapi/migration.json b/qapi/migration.json > index 061ff25..4b980a0 100644 > --- a/qapi/migration.json > +++ b/qapi/migration.json > @@ -1737,3 +1737,53 @@ > ## > { 'enum': 'DirtyRateStatus', > 'data': [ 'unstarted', 'measuring', 'measured'] } > + > +## > +# @DirtyRateInfo: > +# > +# Information about current dirty page rate of vm. > +# > +# @dirty-rate: @dirtyrate describing the dirty page rate of vm > +# in units of MB/s. > +# If this field return '-1', it means querying is not > +# start or not complete. > +# > +# @status: status containing dirtyrate query status includes > +# 'unstarted' or 'measuring' or 'measured' > +# > +# @start-time: start time in units of second for calculation > +# > +# @calc-time: time in units of second for sample dirty pages > +# > +# Since: 5.2 > +# > +## > +{ 'struct': 'DirtyRateInfo', > + 'data': {'dirty-rate': 'int64', > + 'status': 'DirtyRateStatus', > + 'start-time': 'int64', > + 'calc-time': 'int64'} } > + > +## > +# @calc-dirty-rate: > +# > +# start calculating dirty page rate for vm > +# > +# @calc-time: time in units of second for sample dirty pages > +# > +# Since: 5.2 > +# > +# Example: > +# {"command": "calc-dirty-rate", "data": {"calc-time": 1} } > +# > +## > +{ 'command': 'calc-dirty-rate', 'data': {'calc-time': 'int64'} } > + > +## > +# @query-dirty-rate: > +# > +# query dirty page rate in units of MB/s for vm > +# > +# Since: 5.2 > +## > +{ 'command': 'query-dirty-rate', 'returns': 'DirtyRateInfo' } > -- > 1.8.3.1 > >
* Chuan Zheng (zhengchuan@huawei.com) wrote: > Implement qmp_cal_dirty_rate()/qmp_get_dirty_rate() function which could be called > > Signed-off-by: Chuan Zheng <zhengchuan@huawei.com> THis is looking OK by me, Eric: are you happy with the qapi stuff now? Dave > --- > migration/dirtyrate.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++ > qapi/migration.json | 50 +++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 112 insertions(+) > > diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c > index 2f9ac34..e9e9e35 100644 > --- a/migration/dirtyrate.c > +++ b/migration/dirtyrate.c > @@ -61,6 +61,24 @@ static int dirtyrate_set_state(int *state, int old_state, int new_state) > } > } > > +static struct DirtyRateInfo *query_dirty_rate_info(void) > +{ > + int64_t dirty_rate = DirtyStat.dirty_rate; > + struct DirtyRateInfo *info = g_malloc0(sizeof(DirtyRateInfo)); > + > + if (CalculatingState == DIRTY_RATE_STATUS_MEASURED) { > + info->dirty_rate = dirty_rate; > + } else { > + info->dirty_rate = -1; > + } > + > + info->status = CalculatingState; > + info->start_time = DirtyStat.start_time; > + info->calc_time = DirtyStat.calc_time; > + > + return info; > +} > + > static void reset_dirtyrate_stat(void) > { > DirtyStat.total_dirty_samples = 0; > @@ -331,6 +349,8 @@ static void calculate_dirtyrate(struct DirtyRateConfig config) > > msec = config.sample_period_seconds * 1000; > msec = set_sample_page_period(msec, initial_time); > + DirtyStat.start_time = initial_time / 1000; > + DirtyStat.calc_time = msec / 1000; > > rcu_read_lock(); > if (compare_page_hash_info(block_dinfo, block_index) < 0) { > @@ -362,3 +382,45 @@ void *get_dirtyrate_thread(void *arg) > DIRTY_RATE_STATUS_MEASURED); > return NULL; > } > + > +void qmp_calc_dirty_rate(int64_t calc_time, Error **errp) > +{ > + static struct DirtyRateConfig config; > + QemuThread thread; > + int ret; > + > + /* > + * If the dirty rate is already being measured, don't attempt to start. > + */ > + if (CalculatingState == DIRTY_RATE_STATUS_MEASURING) { > + error_setg(errp, "the dirty rate is already being measured."); > + return; > + } > + > + if (!get_sample_page_period(calc_time)) { > + error_setg(errp, "calc-time is out of range[%d, %d].", > + MIN_FETCH_DIRTYRATE_TIME_SEC, > + MAX_FETCH_DIRTYRATE_TIME_SEC); > + return; > + } > + > + /* > + * Init calculation state as unstarted. > + */ > + ret = dirtyrate_set_state(&CalculatingState, CalculatingState, > + DIRTY_RATE_STATUS_UNSTARTED); > + if (ret == -1) { > + error_setg(errp, "init dirty rate calculation state failed."); > + return; > + } > + > + config.sample_period_seconds = calc_time; > + config.sample_pages_per_gigabytes = DIRTYRATE_DEFAULT_SAMPLE_PAGES; > + qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, > + (void *)&config, QEMU_THREAD_DETACHED); > +} > + > +struct DirtyRateInfo *qmp_query_dirty_rate(Error **errp) > +{ > + return query_dirty_rate_info(); > +} > diff --git a/qapi/migration.json b/qapi/migration.json > index 061ff25..4b980a0 100644 > --- a/qapi/migration.json > +++ b/qapi/migration.json > @@ -1737,3 +1737,53 @@ > ## > { 'enum': 'DirtyRateStatus', > 'data': [ 'unstarted', 'measuring', 'measured'] } > + > +## > +# @DirtyRateInfo: > +# > +# Information about current dirty page rate of vm. > +# > +# @dirty-rate: @dirtyrate describing the dirty page rate of vm > +# in units of MB/s. > +# If this field return '-1', it means querying is not > +# start or not complete. > +# > +# @status: status containing dirtyrate query status includes > +# 'unstarted' or 'measuring' or 'measured' > +# > +# @start-time: start time in units of second for calculation > +# > +# @calc-time: time in units of second for sample dirty pages > +# > +# Since: 5.2 > +# > +## > +{ 'struct': 'DirtyRateInfo', > + 'data': {'dirty-rate': 'int64', > + 'status': 'DirtyRateStatus', > + 'start-time': 'int64', > + 'calc-time': 'int64'} } > + > +## > +# @calc-dirty-rate: > +# > +# start calculating dirty page rate for vm > +# > +# @calc-time: time in units of second for sample dirty pages > +# > +# Since: 5.2 > +# > +# Example: > +# {"command": "calc-dirty-rate", "data": {"calc-time": 1} } > +# > +## > +{ 'command': 'calc-dirty-rate', 'data': {'calc-time': 'int64'} } > + > +## > +# @query-dirty-rate: > +# > +# query dirty page rate in units of MB/s for vm > +# > +# Since: 5.2 > +## > +{ 'command': 'query-dirty-rate', 'returns': 'DirtyRateInfo' } > -- > 1.8.3.1 >
On 2020/9/10 22:27, Li Qiang wrote: > Chuan Zheng <zhengchuan@huawei.com> 于2020年9月9日周三 下午10:14写道： >> >> Implement qmp_cal_dirty_rate()/qmp_get_dirty_rate() function which could be called >> >> Signed-off-by: Chuan Zheng <zhengchuan@huawei.com> >> --- >> migration/dirtyrate.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++ >> qapi/migration.json | 50 +++++++++++++++++++++++++++++++++++++++++ >> 2 files changed, 112 insertions(+) >> >> diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c >> index 2f9ac34..e9e9e35 100644 >> --- a/migration/dirtyrate.c >> +++ b/migration/dirtyrate.c >> @@ -61,6 +61,24 @@ static int dirtyrate_set_state(int *state, int old_state, int new_state) >> } >> } >> >> +static struct DirtyRateInfo *query_dirty_rate_info(void) >> +{ >> + int64_t dirty_rate = DirtyStat.dirty_rate; >> + struct DirtyRateInfo *info = g_malloc0(sizeof(DirtyRateInfo)); >> + >> + if (CalculatingState == DIRTY_RATE_STATUS_MEASURED) { > > Should we use atomic read 'CalculatingState'? The qmp thread maybe run > with the sampled thread. > OK, will optimize it in V8 >> + info->dirty_rate = dirty_rate; >> + } else { >> + info->dirty_rate = -1; >> + } >> + >> + info->status = CalculatingState; >> + info->start_time = DirtyStat.start_time; >> + info->calc_time = DirtyStat.calc_time; >> + >> + return info; >> +} >> + > > >> static void reset_dirtyrate_stat(void) >> { >> DirtyStat.total_dirty_samples = 0; >> @@ -331,6 +349,8 @@ static void calculate_dirtyrate(struct DirtyRateConfig config) >> >> msec = config.sample_period_seconds * 1000; >> msec = set_sample_page_period(msec, initial_time); >> + DirtyStat.start_time = initial_time / 1000; >> + DirtyStat.calc_time = msec / 1000; >> >> rcu_read_lock(); >> if (compare_page_hash_info(block_dinfo, block_index) < 0) { >> @@ -362,3 +382,45 @@ void *get_dirtyrate_thread(void *arg) >> DIRTY_RATE_STATUS_MEASURED); >> return NULL; >> } >> + >> +void qmp_calc_dirty_rate(int64_t calc_time, Error **errp) >> +{ >> + static struct DirtyRateConfig config; >> + QemuThread thread; >> + int ret; >> + >> + /* >> + * If the dirty rate is already being measured, don't attempt to start. >> + */ >> + if (CalculatingState == DIRTY_RATE_STATUS_MEASURING) { > > atomic read? > >> + error_setg(errp, "the dirty rate is already being measured."); >> + return; >> + } >> + >> + if (!get_sample_page_period(calc_time)) { >> + error_setg(errp, "calc-time is out of range[%d, %d].", >> + MIN_FETCH_DIRTYRATE_TIME_SEC, >> + MAX_FETCH_DIRTYRATE_TIME_SEC); >> + return; >> + } >> + >> + /* >> + * Init calculation state as unstarted. >> + */ >> + ret = dirtyrate_set_state(&CalculatingState, CalculatingState, >> + DIRTY_RATE_STATUS_UNSTARTED); >> + if (ret == -1) { >> + error_setg(errp, "init dirty rate calculation state failed."); >> + return; >> + } >> + >> + config.sample_period_seconds = calc_time; >> + config.sample_pages_per_gigabytes = DIRTYRATE_DEFAULT_SAMPLE_PAGES; >> + qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, >> + (void *)&config, QEMU_THREAD_DETACHED); >> +} >> + >> +struct DirtyRateInfo *qmp_query_dirty_rate(Error **errp) >> +{ >> + return query_dirty_rate_info(); >> +} >> diff --git a/qapi/migration.json b/qapi/migration.json >> index 061ff25..4b980a0 100644 >> --- a/qapi/migration.json >> +++ b/qapi/migration.json >> @@ -1737,3 +1737,53 @@ >> ## >> { 'enum': 'DirtyRateStatus', >> 'data': [ 'unstarted', 'measuring', 'measured'] } >> + >> +## >> +# @DirtyRateInfo: >> +# >> +# Information about current dirty page rate of vm. >> +# >> +# @dirty-rate: @dirtyrate describing the dirty page rate of vm >> +# in units of MB/s. >> +# If this field return '-1', it means querying is not >> +# start or not complete. >> +# >> +# @status: status containing dirtyrate query status includes >> +# 'unstarted' or 'measuring' or 'measured' >> +# >> +# @start-time: start time in units of second for calculation >> +# >> +# @calc-time: time in units of second for sample dirty pages >> +# >> +# Since: 5.2 >> +# >> +## >> +{ 'struct': 'DirtyRateInfo', >> + 'data': {'dirty-rate': 'int64', >> + 'status': 'DirtyRateStatus', >> + 'start-time': 'int64', >> + 'calc-time': 'int64'} } >> + >> +## >> +# @calc-dirty-rate: >> +# >> +# start calculating dirty page rate for vm >> +# >> +# @calc-time: time in units of second for sample dirty pages >> +# >> +# Since: 5.2 >> +# >> +# Example: >> +# {"command": "calc-dirty-rate", "data": {"calc-time": 1} } >> +# >> +## >> +{ 'command': 'calc-dirty-rate', 'data': {'calc-time': 'int64'} } >> + >> +## >> +# @query-dirty-rate: >> +# >> +# query dirty page rate in units of MB/s for vm >> +# >> +# Since: 5.2 >> +## >> +{ 'command': 'query-dirty-rate', 'returns': 'DirtyRateInfo' } >> -- >> 1.8.3.1 >> >> > > . >
diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c index 2f9ac34..e9e9e35 100644 --- a/migration/dirtyrate.c +++ b/migration/dirtyrate.c @@ -61,6 +61,24 @@ static int dirtyrate_set_state(int *state, int old_state, int new_state) } } +static struct DirtyRateInfo *query_dirty_rate_info(void) +{ + int64_t dirty_rate = DirtyStat.dirty_rate; + struct DirtyRateInfo *info = g_malloc0(sizeof(DirtyRateInfo)); + + if (CalculatingState == DIRTY_RATE_STATUS_MEASURED) { + info->dirty_rate = dirty_rate; + } else { + info->dirty_rate = -1; + } + + info->status = CalculatingState; + info->start_time = DirtyStat.start_time; + info->calc_time = DirtyStat.calc_time; + + return info; +} + static void reset_dirtyrate_stat(void) { DirtyStat.total_dirty_samples = 0; @@ -331,6 +349,8 @@ static void calculate_dirtyrate(struct DirtyRateConfig config) msec = config.sample_period_seconds * 1000; msec = set_sample_page_period(msec, initial_time); + DirtyStat.start_time = initial_time / 1000; + DirtyStat.calc_time = msec / 1000; rcu_read_lock(); if (compare_page_hash_info(block_dinfo, block_index) < 0) { @@ -362,3 +382,45 @@ void *get_dirtyrate_thread(void *arg) DIRTY_RATE_STATUS_MEASURED); return NULL; } + +void qmp_calc_dirty_rate(int64_t calc_time, Error **errp) +{ + static struct DirtyRateConfig config; + QemuThread thread; + int ret; + + /* + * If the dirty rate is already being measured, don't attempt to start. + */ + if (CalculatingState == DIRTY_RATE_STATUS_MEASURING) { + error_setg(errp, "the dirty rate is already being measured."); + return; + } + + if (!get_sample_page_period(calc_time)) { + error_setg(errp, "calc-time is out of range[%d, %d].", + MIN_FETCH_DIRTYRATE_TIME_SEC, + MAX_FETCH_DIRTYRATE_TIME_SEC); + return; + } + + /* + * Init calculation state as unstarted. + */ + ret = dirtyrate_set_state(&CalculatingState, CalculatingState, + DIRTY_RATE_STATUS_UNSTARTED); + if (ret == -1) { + error_setg(errp, "init dirty rate calculation state failed."); + return; + } + + config.sample_period_seconds = calc_time; + config.sample_pages_per_gigabytes = DIRTYRATE_DEFAULT_SAMPLE_PAGES; + qemu_thread_create(&thread, "get_dirtyrate", get_dirtyrate_thread, + (void *)&config, QEMU_THREAD_DETACHED); +} + +struct DirtyRateInfo *qmp_query_dirty_rate(Error **errp) +{ + return query_dirty_rate_info(); +} diff --git a/qapi/migration.json b/qapi/migration.json index 061ff25..4b980a0 100644 --- a/qapi/migration.json +++ b/qapi/migration.json @@ -1737,3 +1737,53 @@ ## { 'enum': 'DirtyRateStatus', 'data': [ 'unstarted', 'measuring', 'measured'] } + +## +# @DirtyRateInfo: +# +# Information about current dirty page rate of vm. +# +# @dirty-rate: @dirtyrate describing the dirty page rate of vm +# in units of MB/s. +# If this field return '-1', it means querying is not +# start or not complete. +# +# @status: status containing dirtyrate query status includes +# 'unstarted' or 'measuring' or 'measured' +# +# @start-time: start time in units of second for calculation +# +# @calc-time: time in units of second for sample dirty pages +# +# Since: 5.2 +# +## +{ 'struct': 'DirtyRateInfo', + 'data': {'dirty-rate': 'int64', + 'status': 'DirtyRateStatus', + 'start-time': 'int64', + 'calc-time': 'int64'} } + +## +# @calc-dirty-rate: +# +# start calculating dirty page rate for vm +# +# @calc-time: time in units of second for sample dirty pages +# +# Since: 5.2 +# +# Example: +# {"command": "calc-dirty-rate", "data": {"calc-time": 1} } +# +## +{ 'command': 'calc-dirty-rate', 'data': {'calc-time': 'int64'} } + +## +# @query-dirty-rate: +# +# query dirty page rate in units of MB/s for vm +# +# Since: 5.2 +## +{ 'command': 'query-dirty-rate', 'returns': 'DirtyRateInfo' }
Implement qmp_cal_dirty_rate()/qmp_get_dirty_rate() function which could be called Signed-off-by: Chuan Zheng <zhengchuan@huawei.com> --- migration/dirtyrate.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++ qapi/migration.json | 50 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 112 insertions(+)