virtio: Report new guest memory statistics pertinent to memory ballooning (V2)
Subsystems (2)
RFC 1/1 virtio: Report new guest memory statistics pertinent to memory ballooning (V2)
Changes since V1:
- In the monitor, print all stats on one line with less abbreviated names
- Coding style changes
When using ballooning to manage overcommitted memory on a host, a system for guests to communicate their memory usage to the host can provide information that will minimize the impact of ballooning on the guests. The current method employs a daemon running in each guest that communicates memory statistics to a host daemon at a specified time interval. The host daemon aggregates this information and inflates and/or deflates balloons according to the level of host memory pressure. This approach is effective but overly complex since a daemon must be installed inside each guest and coordinated to communicate with the host. A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
This patch implements the qemu side of the communication channel. I will post the kernel driver modifications in-reply to this message.
balloon.h +9 -2
@@ -14,14 +14,21 @@#ifndef _QEMU_BALLOON_H#define _QEMU_BALLOON_H +#include "hw/virtio-balloon.h" #include "cpu-defs.h" -typedef ram_addr_t (QEMUBalloonEvent )(void *opaque,ram_addr_t target); +typedef struct QEMUBalloonState { +ram_addr_t actual; +virtio_balloon_stats stats; +}QEMUBalloonState ; + +typedef void (QEMUBalloonEvent )(void *opaque,ram_addr_t target, +QEMUBalloonState *state);void qemu_add_balloon_handler (QEMUBalloonEvent *func,void *opaque);void qemu_balloon (ram_addr_t target); -ram_addr_t qemu_balloon_status (void ); +int qemu_balloon_status (QEMUBalloonState *s);#endif
hw/virtio-balloon.c +56 -8
101 lines not on this page · raw message
hw/virtio-balloon.h +21 -0
@@ -25,16 +25,37 @@/* The feature bitmap for virtio balloon */ #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0/* Tell before reclaiming pages */ +/* Guest memory statistic reporting */ +#define VIRTIO_BALLOON_F_RPT_SWAP_IN 1/* Number of pages swapped in */ +#define VIRTIO_BALLOON_F_RPT_SWAP_OUT 2/* Number of pages swapped out */ +#define VIRTIO_BALLOON_F_RPT_ANON 3/* Number of anonymous pages in use */ +#define VIRTIO_BALLOON_F_RPT_MAJFLT 4/* Number of major faults */ +#define VIRTIO_BALLOON_F_RPT_MINFLT 5/* Number of minor faults */ +#define VIRTIO_BALLOON_F_RPT_MEMFREE 6/* Total amount of free memory */ +#define VIRTIO_BALLOON_F_RPT_MEMTOT 7/* Total amount of memory */ /* Size of a PFN in the balloon interface. */ #define VIRTIO_BALLOON_PFN_SHIFT 12 +typedef struct virtio_balloon_stats +{ +uint32_t pswapin;/* pages swapped in */ +uint32_t pswapout;/* pages swapped out */ +uint32_t panon;/* anonymous pages in use */ +uint32_t pgmajfault;/* Major page faults */ +uint32_t pgminfault;/* Minor page faults */ +uint32_t memfree;/* Total amount of free memory (in kb) */ +uint32_t memtot;/* Total amount of memory (in kb) */ +}virtio_balloon_stats ; +struct virtio_balloon_config {/* Number of pages host wants Guest to give up. */ uint32_t num_pages;/* Number of pages we've actually got in balloon. */ uint32_t actual; +/* Memory statistics */ +virtio_balloon_stats stats; };#endif
monitor.c +24 -6
@@ -1581,18 +1581,36 @@ static void do_balloon(Monitor *mon, int value)qemu_balloon (target <<20 ); } +static inline void print_stat (Monitor *mon,uint32_t val,const char *label) +{ +if (val !=-1 ) { +monitor_printf (mon,",%s=%u" , label, val); + } +} +static void do_info_balloon (Monitor *mon) { -ram_addr_t actual; +QEMUBalloonState s; +int ret; - actual =qemu_balloon_status (); -if (kvm_enabled () && !kvm_has_sync_mmu ()) + ret =qemu_balloon_status (&s); +if (kvm_enabled () && !kvm_has_sync_mmu ()) {monitor_printf (mon,"Using KVM without synchronous MMU, " "ballooning disabled\n" ); -else if (actual ==0 ) + }else if (ret <0 ) {monitor_printf (mon,"Ballooning not activated in VM\n" ); -else -monitor_printf (mon,"balloon: actual=%d\n" , (int )(actual >>20 )); + }else { +monitor_printf (mon,"balloon: actual=%d" , (int )(s.actual >>20 )); +print_stat (mon, s.stats.pswapin,"pages_swapped_in" ); +print_stat (mon, s.stats.pswapout,"pages_swapped_out" ); +print_stat (mon, s.stats.panon,"anon_pages" ); +print_stat (mon, s.stats.pgmajfault,"major_page_faults" ); +print_stat (mon, s.stats.pgminfault,"minor_page_faults" ); +print_stat (mon, s.stats.memfree,"free_memory" ); +print_stat (mon, s.stats.memtot,"total_memory" ); +monitor_printf (mon,"\n" ); + } + }static qemu_acl *find_acl (Monitor *mon,const char *name)
vl.c +3 -3
@@ -334,13 +334,13 @@ void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)void qemu_balloon (ram_addr_t target) {if (qemu_balloon_event) -qemu_balloon_event (qemu_balloon_event_opaque, target); +qemu_balloon_event (qemu_balloon_event_opaque, target,NULL ); } -ram_addr_t qemu_balloon_status (void ) +int qemu_balloon_status (struct QEMUBalloonState *s) {if (qemu_balloon_event) -return qemu_balloon_event (qemu_balloon_event_opaque,0 ); +qemu_balloon_event (qemu_balloon_event_opaque,0 , s);return 0 ; }
Signature · 2 lines
Thanks, Adam
virtio: Add memory statistics reporting to the balloon driver
When using ballooning to manage overcommitted memory on a host, a system for guests to communicate their memory usage to the host can provide information that will minimize the impact of ballooning on the guests. The current method employs a daemon running in each guest that communicates memory statistics to a host daemon at a specified time interval. The host daemon aggregates this information and inflates and/or deflates balloons according to the level of host memory pressure. This approach is effective but overly complex since a daemon must be installed inside each guest and coordinated to communicate with the host. A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
This patch enables the guest-side support by adding stats collection and reporting to the virtio balloon driver.
Comments?
drivers/virtio/virtio_balloon.c +45 -3
@@ -180,6 +180,41 @@ static void update_balloon_size(struct virtio_balloon *vb) &actual, sizeof(actual)); } +static inline void update_stat (struct virtio_device *vdev,int feature, +unsigned long value,unsigned offset) +{ +__le32 __v =cpu_to_le32 (value); +if (virtio_has_feature (vdev, feature)) + vdev->config->set (vdev, offset, &__v,sizeof (__v)); +} + +#define K (x) ((x) << (PAGE_SHIFT - 10)) +static void update_balloon_stats (struct virtio_balloon *vb) +{ +unsigned long events[NR_VM_EVENT_ITEMS ]; +struct sysinfo i; +unsigned off = offsetof(struct virtio_balloon_config , stats); + +all_vm_events (events); + +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_SWAP_IN , events[PSWPIN ], + off + offsetof(struct virtio_balloon_stats , pswapin)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_SWAP_OUT , events[PSWPOUT ], + off + offsetof(struct virtio_balloon_stats , pswapout)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MAJFLT , events[PGMAJFAULT ], + off + offsetof(struct virtio_balloon_stats , pgmajfault)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MINFLT , events[PGFAULT ], + off + offsetof(struct virtio_balloon_stats , pgminfault)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_ANON , +K (global_page_state (NR_ANON_PAGES )), + off + offsetof(struct virtio_balloon_stats , panon)); +si_meminfo (&i); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MEMFREE ,K (i.freeram), + off + offsetof(struct virtio_balloon_stats , memfree)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MEMTOT ,K (i.totalram), + off + offsetof(struct virtio_balloon_stats , memtot)); +} +static int balloon (void *_vballoon) {struct virtio_balloon *vb = _vballoon;
@@ -189,15 +224,17 @@ static int balloon(void *_vballoon)s64 diff;try_to_freeze (); -wait_event_interruptible (vb->config_change, +wait_event_interruptible_timeout (vb->config_change, (diff =towards_target (vb)) !=0 ||kthread_should_stop () - ||freezing (current)); + ||freezing (current), +VIRTIO_BALLOON_TIMEOUT );if (diff >0 )fill_balloon (vb, diff);else if (diff <0 )leak_balloon (vb, -diff);update_balloon_size (vb); +update_balloon_stats (vb); }return 0 ; }
@@ -265,7 +302,12 @@ static void virtballoon_remove(struct virtio_device *vdev)kfree (vb); } -static unsigned int features[] = {VIRTIO_BALLOON_F_MUST_TELL_HOST }; +static unsigned int features[] = { +VIRTIO_BALLOON_F_MUST_TELL_HOST ,VIRTIO_BALLOON_F_RPT_SWAP_IN , +VIRTIO_BALLOON_F_RPT_SWAP_OUT ,VIRTIO_BALLOON_F_RPT_ANON , +VIRTIO_BALLOON_F_RPT_MAJFLT ,VIRTIO_BALLOON_F_RPT_MINFLT , +VIRTIO_BALLOON_F_RPT_MEMFREE ,VIRTIO_BALLOON_F_RPT_MEMTOT , +};static struct virtio_driver virtio_balloon = { .feature_table = features,
include/linux/virtio_balloon.h +24 -0
@@ -6,15 +6,39 @@/* The feature bitmap for virtio balloon */ #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0/* Tell before reclaiming pages */ +/* Guest memory statistic reporting */ +#define VIRTIO_BALLOON_F_RPT_SWAP_IN 1/* Number of pages swapped in */ +#define VIRTIO_BALLOON_F_RPT_SWAP_OUT 2/* Number of pages swapped out */ +#define VIRTIO_BALLOON_F_RPT_ANON 3/* Number of anonymous pages in use */ +#define VIRTIO_BALLOON_F_RPT_MAJFLT 4/* Number of major faults */ +#define VIRTIO_BALLOON_F_RPT_MINFLT 5/* Number of minor faults */ +#define VIRTIO_BALLOON_F_RPT_MEMFREE 6/* Total amount of free memory */ +#define VIRTIO_BALLOON_F_RPT_MEMTOT 7/* Total amount of memory */ /* Size of a PFN in the balloon interface. */ #define VIRTIO_BALLOON_PFN_SHIFT 12 +struct virtio_balloon_stats +{ +__le32 pswapin;/* pages swapped in */ +__le32 pswapout;/* pages swapped out */ +__le32 panon;/* anonymous pages in use (in kb) */ +__le32 pgmajfault;/* Major page faults */ +__le32 pgminfault;/* Minor page faults */ +__le32 memfree;/* Total amount of free memory (in kb) */ +__le32 memtot;/* Total amount of memory (in kb) */ +}; +struct virtio_balloon_config {/* Number of pages host wants Guest to give up. */ __le32 num_pages;/* Number of pages we've actually got in balloon. */ __le32 actual; +/* Memory statistics */ +struct virtio_balloon_stats stats; }; + +#define VIRTIO_BALLOON_TIMEOUT (30 * HZ) +#endif /* _LINUX_VIRTIO_BALLOON_H */
Signature · 2 lines
Thanks, Adam
virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeWhen using ballooning to manage overcommitted memory on a host, a system for guests to communicate their memory usage to the host can provide information that will minimize the impact of ballooning on the guests. The current method employs a daemon running in each guest that communicates memory statistics to a host daemon at a specified time interval. The host daemon aggregates this information and inflates and/or deflates balloons according to the level of host memory pressure. This approach is effective but overly complex since a daemon must be installed inside each guest and coordinated to communicate with the host. A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
This patch enables the guest-side support by adding stats collection and reporting to the virtio balloon driver.
Comments?
drivers/virtio/virtio_balloon.c +45 -3
@@ -180,6 +180,41 @@ static void update_balloon_size(struct virtio_balloon *vb) &actual, sizeof(actual)); } +static inline void update_stat (struct virtio_device *vdev,int feature, +unsigned long value,unsigned offset) +{ +__le32 __v =cpu_to_le32 (value); +if (virtio_has_feature (vdev, feature)) + vdev->config->set (vdev, offset, &__v,sizeof (__v)); +} + +#define K (x) ((x) << (PAGE_SHIFT - 10)) +static void update_balloon_stats (struct virtio_balloon *vb) +{ +unsigned long events[NR_VM_EVENT_ITEMS ]; +struct sysinfo i; +unsigned off = offsetof(struct virtio_balloon_config , stats); + +all_vm_events (events); + +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_SWAP_IN , events[PSWPIN ], + off + offsetof(struct virtio_balloon_stats , pswapin)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_SWAP_OUT , events[PSWPOUT ], + off + offsetof(struct virtio_balloon_stats , pswapout)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MAJFLT , events[PGMAJFAULT ], + off + offsetof(struct virtio_balloon_stats , pgmajfault)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MINFLT , events[PGFAULT ], + off + offsetof(struct virtio_balloon_stats , pgminfault)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_ANON , +K (global_page_state (NR_ANON_PAGES )), + off + offsetof(struct virtio_balloon_stats , panon)); +si_meminfo (&i); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MEMFREE ,K (i.freeram), + off + offsetof(struct virtio_balloon_stats , memfree)); +update_stat (vb->vdev,VIRTIO_BALLOON_F_RPT_MEMTOT ,K (i.totalram), + off + offsetof(struct virtio_balloon_stats , memtot)); +} +static int balloon (void *_vballoon) {struct virtio_balloon *vb = _vballoon;
@@ -189,15 +224,17 @@ static int balloon(void *_vballoon)s64 diff;try_to_freeze (); -wait_event_interruptible (vb->config_change, +wait_event_interruptible_timeout (vb->config_change, (diff =towards_target (vb)) !=0 ||kthread_should_stop () - ||freezing (current)); + ||freezing (current), +VIRTIO_BALLOON_TIMEOUT );if (diff >0 )fill_balloon (vb, diff);else if (diff <0 )leak_balloon (vb, -diff);update_balloon_size (vb); +update_balloon_stats (vb); }return 0 ; }
@@ -265,7 +302,12 @@ static void virtballoon_remove(struct virtio_device *vdev)kfree (vb); } -static unsigned int features[] = {VIRTIO_BALLOON_F_MUST_TELL_HOST }; +static unsigned int features[] = { +VIRTIO_BALLOON_F_MUST_TELL_HOST ,VIRTIO_BALLOON_F_RPT_SWAP_IN , +VIRTIO_BALLOON_F_RPT_SWAP_OUT ,VIRTIO_BALLOON_F_RPT_ANON , +VIRTIO_BALLOON_F_RPT_MAJFLT ,VIRTIO_BALLOON_F_RPT_MINFLT , +VIRTIO_BALLOON_F_RPT_MEMFREE ,VIRTIO_BALLOON_F_RPT_MEMTOT , +};static struct virtio_driver virtio_balloon = { .feature_table = features,
include/linux/virtio_balloon.h +24 -0
@@ -6,15 +6,39 @@/* The feature bitmap for virtio balloon */ #define VIRTIO_BALLOON_F_MUST_TELL_HOST 0/* Tell before reclaiming pages */ +/* Guest memory statistic reporting */ +#define VIRTIO_BALLOON_F_RPT_SWAP_IN 1/* Number of pages swapped in */ +#define VIRTIO_BALLOON_F_RPT_SWAP_OUT 2/* Number of pages swapped out */ +#define VIRTIO_BALLOON_F_RPT_ANON 3/* Number of anonymous pages in use */ +#define VIRTIO_BALLOON_F_RPT_MAJFLT 4/* Number of major faults */ +#define VIRTIO_BALLOON_F_RPT_MINFLT 5/* Number of minor faults */ +#define VIRTIO_BALLOON_F_RPT_MEMFREE 6/* Total amount of free memory */ +#define VIRTIO_BALLOON_F_RPT_MEMTOT 7/* Total amount of memory */ /* Size of a PFN in the balloon interface. */ #define VIRTIO_BALLOON_PFN_SHIFT 12 +struct virtio_balloon_stats +{ +__le32 pswapin;/* pages swapped in */ +__le32 pswapout;/* pages swapped out */ +__le32 panon;/* anonymous pages in use (in kb) */ +__le32 pgmajfault;/* Major page faults */ +__le32 pgminfault;/* Minor page faults */ +__le32 memfree;/* Total amount of free memory (in kb) */ +__le32 memtot;/* Total amount of memory (in kb) */ +}; +struct virtio_balloon_config {/* Number of pages host wants Guest to give up. */ __le32 num_pages;/* Number of pages we've actually got in balloon. */ __le32 actual; +/* Memory statistics */ +struct virtio_balloon_stats stats; }; + +#define VIRTIO_BALLOON_TIMEOUT (30 * HZ) +#endif /* _LINUX_VIRTIO_BALLOON_H */
Signature · 2 lines
Thanks, Adam
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 2 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
Rusty.
[Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeQuoted 2 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
Rusty.
[Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeQuoted 2 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeQuoted 2 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
Rusty.
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 8 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent.
Actually, config writes always require notification from the guest to the host. This means the host knows when they config space is changed so atomicity isn't a problem.
In fact, if it were a problem, then the balloon driver would be fundamentally broken because target and actual are stored in the config space.
If you recall, we had this discussion originally wrt the balloon driver :-)
Quoted 3 lines
Second, polling is
ugly.
As opposed to? The guest could set a timer and update the values periodically but that's even uglier because then the host cannot determine the update granularity.
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Regards,
Anthony Liguori
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Rusty RussellQuoted 8 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent.
Actually, config writes always require notification from the guest to the host. This means the host knows when they config space is changed so atomicity isn't a problem.
In fact, if it were a problem, then the balloon driver would be fundamentally broken because target and actual are stored in the config space.
If you recall, we had this discussion originally wrt the balloon driver :-)
Quoted 3 lines
Second, polling is
ugly.
As opposed to? The guest could set a timer and update the values periodically but that's even uglier because then the host cannot determine the update granularity.
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Regards,
Anthony Liguori
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Signature · 1 line
error compiling committee.c: too many arguments to function
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 5 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Signature · 1 line
error compiling committee.c: too many arguments to function
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 10 lines · Avi Kivity
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Quoted 6 lines
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
Signature · 3 lines
Regards, Anthony Liguori
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Avi KivityQuoted 8 lines · Avi Kivity
Quoted 5 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
Signature · 3 lines
Regards, Anthony Liguori
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 18 lines · Anthony Liguori
Quoted 10 lines · Avi Kivity
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Quoted 6 lines
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Quoted 3 lines
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
If there's no memory pressure and no guest activity, you probably want the stat update to be as rare as possible to avoid wakeups. Save power on laptops, that sort of thing.
If there's a host user interested in the state ("qemutop?"), you may want updates more often than 10s.
-- Jamie
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 18 lines · Anthony Liguori
Quoted 10 lines · Avi Kivity
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Quoted 6 lines
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Quoted 3 lines
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
If there's no memory pressure and no guest activity, you probably want the stat update to be as rare as possible to avoid wakeups. Save power on laptops, that sort of thing.
If there's a host user interested in the state ("qemutop?"), you may want updates more often than 10s.
-- Jamie
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 23 lines · Jamie Lokier
Quoted 18 lines · Anthony Liguori
Quoted 10 lines · Avi Kivity
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Quoted 6 lines
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Quoted 3 lines
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
Quoted 6 lines
If there's no memory pressure and no guest activity, you probably want the stat update to be as rare as possible to avoid wakeups. Save power on laptops, that sort of thing.
If there's a host user interested in the state ("qemutop?"), you may want updates more often than 10s.
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Daniel
Signature · 4 lines
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Jamie LokierQuoted 23 lines · Jamie Lokier
Quoted 18 lines · Anthony Liguori
Quoted 10 lines · Avi Kivity
Quoted 8 lines · Anthony Liguori
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
Quoted 6 lines
There is in fact a difference; actual and target are very rarely updated, while the stats are updated very often. Using a vq means a constant number of exits per batch instead of one exit per statistic. If the vq is host-driven, it also allows the host to control the update frequency dynamically (i.e. stop polling when there is no memory pressure).
Quoted 3 lines
I'm not terribly opposed to using a vq for this. I would expect the stat update interval to be rather long (10s probably) but a vq works just as well.
Quoted 6 lines
If there's no memory pressure and no guest activity, you probably want the stat update to be as rare as possible to avoid wakeups. Save power on laptops, that sort of thing.
If there's a host user interested in the state ("qemutop?"), you may want updates more often than 10s.
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Daniel
Signature · 4 lines
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 4 lines · Daniel P. Berrange
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Agreed. The next version of the patch will remove the timer completely. We'll wake up in response to config change notifications only.
Signature · 2 lines
Thanks, Adam
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Daniel P. BerrangeQuoted 4 lines · Daniel P. Berrange
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Agreed. The next version of the patch will remove the timer completely. We'll wake up in response to config change notifications only.
Signature · 2 lines
Thanks, Adam
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 10 lines · Adam Litke
Quoted 5 lines · Daniel P. Berrange
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Agreed. The next version of the patch will remove the timer completely. We'll wake up in response to config change notifications only.
A vq with its own interrupt would be much nicer.
Signature · 1 line
Do not meddle in the internals of kernels, for they are subtle and quick to panic.
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeQuoted 10 lines · Adam Litke
Quoted 5 lines · Daniel P. Berrange
This all suggests that we should only update the stats from the guest when something on the host actually asks for them by issuing the QEMU monitor command. We don't want any kind of continuous polling of stats at any frequency, if nothing is using these stats on the host.
Agreed. The next version of the patch will remove the timer completely. We'll wake up in response to config change notifications only.
A vq with its own interrupt would be much nicer.
Signature · 1 line
Do not meddle in the internals of kernels, for they are subtle and quick to panic.
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 7 lines · Anthony Liguori
Quoted 6 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
Quoted 6 lines
Quoted 2 lines
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent.
Actually, config writes always require notification from the guest to the host. This means the host knows when they config space is changed so atomicity isn't a problem.
I think you missed my point: the stats are inter-related, so they should be served together.
Quoted 3 lines
In fact, if it were a problem, then the balloon driver would be fundamentally broken because target and actual are stored in the config space.
No, one is written by the host, the other the guest. Still works.
Quoted 1 line
If you recall, we had this discussion originally wrt the balloon driver :-)
And I never did get around to the lguest implementation, which would have seen if this really is an issue.
Quoted 3 lines
Quoted 1 line
Second, polling is ugly.
As opposed to?
As opposed to giving the stats whenever asked by the host.
Quoted 7 lines
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
It does, *if* we don't need accuracy. Otherwise, it seems like we need something else.
Cheers,
Rusty.
Re: [Qemu-devel] Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 7 lines · Anthony Liguori
Quoted 6 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
Quoted 6 lines
Quoted 2 lines
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent.
Actually, config writes always require notification from the guest to the host. This means the host knows when they config space is changed so atomicity isn't a problem.
I think you missed my point: the stats are inter-related, so they should be served together.
Quoted 3 lines
In fact, if it were a problem, then the balloon driver would be fundamentally broken because target and actual are stored in the config space.
No, one is written by the host, the other the guest. Still works.
Quoted 1 line
If you recall, we had this discussion originally wrt the balloon driver :-)
And I never did get around to the lguest implementation, which would have seen if this really is an issue.
Quoted 3 lines
Quoted 1 line
Second, polling is ugly.
As opposed to?
As opposed to giving the stats whenever asked by the host.
Quoted 7 lines
Quoted 2 lines
A stats vq might solve this more cleanly?
actual and target are both really just stats. Had we implemented those with a vq, I'd be inclined to agree with you but since they're implemented in the config space, it seems natural to extend the config space with other stats.
It does, *if* we don't need accuracy. Otherwise, it seems like we need something else.
Cheers,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Rusty RussellQuoted 6 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
Quoted 6 lines
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Quoted 2 lines
Rusty.
Signature · 3 lines
Regards, Anthony Liguori
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Rusty RussellQuoted 6 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
Quoted 6 lines
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Quoted 2 lines
Rusty.
Signature · 3 lines
Regards, Anthony Liguori
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 11 lines · Anthony Liguori
Quoted 10 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
Quoted 7 lines
Quoted 2 lines
A stats vq might solve this more cleanly?
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
Quoted 2 lines
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Sure, I want to. You want to. It's simple.
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
Cheers,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 18 lines · Rusty Russell
Quoted 16 lines · Anthony Liguori
Quoted 14 lines · Rusty Russell
Quoted 4 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
A stats vq might solve this more cleanly?
Quoted 9 lines
Quoted 5 lines
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
That's strangely backwards. Guest send a stat buffer that's filled out, host acks it when it wants another. That doesn't seem bizarre to you?
Quoted 9 lines
Quoted 3 lines
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Sure, I want to. You want to. It's simple.
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Quoted 3 lines
Cheers,
Rusty.
Signature · 3 lines
Regards, Anthony Liguori
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Rusty RussellQuoted 15 lines · Rusty Russell
Quoted 13 lines · Anthony Liguori
Quoted 11 lines · Rusty Russell
Quoted 4 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
Quoted 9 lines
Quoted 5 lines
Quoted 3 lines
A stats vq might solve this more cleanly?
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
That's strangely backwards. Guest send a stat buffer that's filled out, host acks it when it wants another. That doesn't seem bizarre to you?
Quoted 8 lines
Quoted 2 lines
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Sure, I want to. You want to. It's simple.
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Quoted 3 lines
Cheers,
Rusty.
Signature · 3 lines
Regards, Anthony Liguori
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 6 lines · Anthony Liguori
Quoted 2 lines · Rusty Russell
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
That's strangely backwards. Guest send a stat buffer that's filled out, host acks it when it wants another. That doesn't seem bizarre to you?
Yep! But that's a limitation of our brains, not the infrastructure ;)
Think of the stats as an infinite stream of data. Read from it at your leisure. This is how, for example, console output works.
Quoted 5 lines
Quoted 2 lines
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Because it's a COLLECTION of stats. For example, swap in should be < swap out. Now, the current Linux implementation of all_vm_events() is non-atomic anyway, so maybe we can just document this as best-effort. I'm saying that if it *is* a problem, I think we need a vq.
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
(I just made those up, of course, but it seems like that would give a fair indication of real memory pressure in any OS).
Thanks,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 6 lines · Anthony Liguori
Quoted 2 lines · Rusty Russell
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
That's strangely backwards. Guest send a stat buffer that's filled out, host acks it when it wants another. That doesn't seem bizarre to you?
Yep! But that's a limitation of our brains, not the infrastructure ;)
Think of the stats as an infinite stream of data. Read from it at your leisure. This is how, for example, console output works.
Quoted 5 lines
Quoted 2 lines
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Because it's a COLLECTION of stats. For example, swap in should be < swap out. Now, the current Linux implementation of all_vm_events() is non-atomic anyway, so maybe we can just document this as best-effort. I'm saying that if it *is* a problem, I think we need a vq.
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
(I just made those up, of course, but it seems like that would give a fair indication of real memory pressure in any OS).
Thanks,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 7 lines · Rusty Russell
Quoted 2 lines
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Because it's a COLLECTION of stats. For example, swap in should be < swap out. Now, the current Linux implementation of
all_vm_events()is non-atomic anyway, so maybe we can just document this as best-effort. I'm saying that if it *is* a problem, I think we need a vq.
I can't see why we would care about the atomicity of the collection of statistics. Best-effort is good enough. Any variance within the stats will be overshadowed by the latency of the host-side management daemon.
Quoted 4 lines
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
While I see the virtue in presenting abstracted memory stats that seem more digestible in a virtualization context, I think we should keep the raw stats. This concentrates the complexity in the host-side management daemon, and allows the host daemon to make better decisions (ie. by reacting to trends in individual statistics). Different OSes (or different versions of the same OS), may also have different sets of statistics that will provide the answers that a management daemon needs.
Signature · 2 lines
Thanks, Adam
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Rusty RussellQuoted 7 lines · Rusty Russell
Quoted 2 lines
It's not laziness, it's consistency. How is actual different than free memory or any other stat?
Because it's a COLLECTION of stats. For example, swap in should be < swap out. Now, the current Linux implementation of
all_vm_events()is non-atomic anyway, so maybe we can just document this as best-effort. I'm saying that if it *is* a problem, I think we need a vq.
I can't see why we would care about the atomicity of the collection of statistics. Best-effort is good enough. Any variance within the stats will be overshadowed by the latency of the host-side management daemon.
Quoted 4 lines
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
While I see the virtue in presenting abstracted memory stats that seem more digestible in a virtualization context, I think we should keep the raw stats. This concentrates the complexity in the host-side management daemon, and allows the host daemon to make better decisions (ie. by reacting to trends in individual statistics). Different OSes (or different versions of the same OS), may also have different sets of statistics that will provide the answers that a management daemon needs.
Signature · 2 lines
Thanks, Adam
Re: virtio: Add memory statistics reporting to the balloon driver
Quoted 5 lines · Adam Litke
Quoted 4 lines
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
Quoted 7 lines
While I see the virtue in presenting abstracted memory stats that seem more digestible in a virtualization context, I think we should keep the raw stats. This concentrates the complexity in the host-side management daemon, and allows the host daemon to make better decisions (ie. by reacting to trends in individual statistics). Different OSes (or different versions of the same OS), may also have different sets of statistics that will provide the answers that a management daemon needs.
OK, I see you made each one a separate feature bit, which does allow this somewhat. But you can't just change the meaning arbitrarily, all you can do is refuse to supply some of them. This is because virtio is an ABI, but also it's plain sanity: run a new guest on an old host and get crazy answers.
Two more questions:
I assume memtot should be equal to the initial memory granted to the guest (perhaps reduced if the guest can't use all the memory for internal reasons)?
I'm not sure of the relevance to the host of the number of anonymous pages? That's why I wondered if unswappable pages would be a better number to supply?
Thanks,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Adam LitkeQuoted 5 lines · Adam Litke
Quoted 4 lines
But it raises the question: what stats are generally useful cross-OS? Should we be supplying numbers like "unused" (free) "instantly discardable" (ie. clean), "discardable to disk" (ie. file-backed), "discardable to swap" (ie. swap-backed) and "unswappable" instead?
Quoted 7 lines
While I see the virtue in presenting abstracted memory stats that seem more digestible in a virtualization context, I think we should keep the raw stats. This concentrates the complexity in the host-side management daemon, and allows the host daemon to make better decisions (ie. by reacting to trends in individual statistics). Different OSes (or different versions of the same OS), may also have different sets of statistics that will provide the answers that a management daemon needs.
OK, I see you made each one a separate feature bit, which does allow this somewhat. But you can't just change the meaning arbitrarily, all you can do is refuse to supply some of them. This is because virtio is an ABI, but also it's plain sanity: run a new guest on an old host and get crazy answers.
Two more questions:
I assume memtot should be equal to the initial memory granted to the guest (perhaps reduced if the guest can't use all the memory for internal reasons)?
I'm not sure of the relevance to the host of the number of anonymous pages? That's why I wondered if unswappable pages would be a better number to supply?
Thanks,
Rusty.
Re: virtio: Add memory statistics reporting to the balloon driver
In reply to Anthony LiguoriQuoted 11 lines · Anthony Liguori
Quoted 10 lines · Rusty Russell
Quoted 3 lines · Adam Litke
A simpler approach is to collect memory statistics in the virtio balloon driver and communicate them to the host via the device config space.
There are two issues I see with this. First, there's an atomicity problem since you can't tell when the stats are consistent. Second, polling is ugly.
Quoted 7 lines
Quoted 2 lines
A stats vq might solve this more cleanly?
This turns out to not work so nicely. You really need bidirectional communication. You need to request that stats be collected and then you need to tell the hypervisor about the stats that were collected. You don't need any real correlation between requests and stat reports either.
You register an outbuf at initialization time. The host hands it back when it wants you to refill it with stats.
Quoted 2 lines
This really models how target/actual work and I think it suggests that we want to reuse that mechanism for the stats too.
Sure, I want to. You want to. It's simple.
But the universe is remarkably indifferent to what we want. Is it actually sufficient or are we going to regret our laziness?
Cheers,
Rusty.
hw/virtio-balloon.c static ram_addr_t virtio_balloon_to_target(void *opaque, ram_addr_t target) · line 178
Quoted 2 lines · Adam Litke
hw/virtio-balloon.c +2
-0+ s->stats.pswapin =has_feature (dev,VIRTIO_BALLOON_F_RPT_SWAP_OUT ) ? + dev->stats.pswapin :-1 ;
(etc.)
Why not simply have the guest fill in the unused fields with -1, and say that's how "no meaningful value" is represented in the ABI?
All guests have to know about all those fields anyway, for the structure layout. Is there any benefit to specifying feature bits in advance over simply storing -1 there?
-- Jamie
Quoted 4 lines · Jamie Lokier
hw/virtio-balloon.c static ram_addr_t virtio_balloon_to_target(void *opaque, ram_addr_t target) · line 178
Quoted 2 lines · Adam Litke
hw/virtio-balloon.c +2
-0+ s->stats.pswapin =has_feature (dev,VIRTIO_BALLOON_F_RPT_SWAP_OUT ) ? + dev->stats.pswapin :-1 ;
Quoted 8 lines
(etc.)
Why not simply have the guest fill in the unused fields with -1, and say that's how "no meaningful value" is represented in the ABI?
All guests have to know about all those fields anyway, for the structure layout. Is there any benefit to specifying feature bits in advance over simply storing -1 there?
This holds true for fields that exist but might not be supported by a guest, but what about the case where we add a new field? In that case, qemu and the guest may disagree on the structure layout.
Signature · 2 lines
Thanks, Adam
Quoted 6 lines · Jamie Lokier
hw/virtio-balloon.c static ram_addr_t virtio_balloon_to_target(void *opaque, ram_addr_t target) · line 178
Quoted 3 lines · Adam Litke
hw/virtio-balloon.c +2
-0+ s->stats.pswapin =has_feature (dev,VIRTIO_BALLOON_F_RPT_SWAP_OUT ) ? + dev->stats.pswapin :-1 ;
Quoted 9 lines
(etc.)
Why not simply have the guest fill in the unused fields with -1, and say that's how "no meaningful value" is represented in the ABI?
All guests have to know about all those fields anyway, for the structure layout. Is there any benefit to specifying feature bits in advance over simply storing -1 there?
Features are negotiated. It lets a host advertise the support of a feature and it lets the guest acknowledge it's support of a feature.
Most importantly, why invent a new mechanism when we already have one?
Signature · 3 lines
Regards, Anthony Liguori
Quoted 18 lines · Anthony Liguori
Quoted 7 lines · Jamie Lokier
Quoted 4 lines · Adam Litke
+
s->stats.pswapin= has_feature(dev,VIRTIO_BALLOON_F_RPT_SWAP_OUT) ?
+dev->stats.pswapin: -1;Quoted 9 lines
(etc.)
Why not simply have the guest fill in the unused fields with -1, and say that's how "no meaningful value" is represented in the ABI?
All guests have to know about all those fields anyway, for the structure layout. Is there any benefit to specifying feature bits in advance over simply storing -1 there?
Quoted 4 lines
Features are negotiated. It lets a host advertise the support of a feature and it lets the guest acknowledge it's support of a feature.
Most importantly, why invent a new mechanism when we already have one?
In this case, the guest already has to have those fields in the structure. It's not like something where the guest doesn't know about a feature at all, and then a later driver adds new capabilities. That would require feature bits or an ABI version, I agree.
But the real motivation for my comment was seeing the bulk of the patch being definitions and tests for lots of feature bits which do something trivial that the guest can easily do.
The feature bits don't seem to simplify anything in this case. As for preparing to be consistent with future additions, presumably if another 20 fields are added, there won't be sufficient bits in the feature word anyway, so an "extended feature bits" feature will be needed.
-- Jamie
Quoted 27 lines · Adam Litke
monitor.c +15
-6+static inline void print_stat (Monitor *mon,uint32_t val,const char *label) +{ +if (val !=-1 ) { +monitor_printf (mon,",%s=%u" , label, val); + } +} +static void do_info_balloon (Monitor *mon) { -ram_addr_t actual; +QEMUBalloonState s; +int ret; - actual =qemu_balloon_status (); -if (kvm_enabled () && !kvm_has_sync_mmu ()) + ret =qemu_balloon_status (&s); +if (kvm_enabled () && !kvm_has_sync_mmu ()) {monitor_printf (mon,"Using KVM without synchronous MMU, " "ballooning disabled\n" ); -else if (actual ==0 ) + }else if (ret <0 ) {monitor_printf (mon,"Ballooning not activated in VM\n" ); -else -monitor_printf (mon,"balloon: actual=%d\n" , (int )(actual >>20 )); + }else { +monitor_printf (mon,"balloon: actual=%d" , (int )(s.actual >>20 )); +print_stat (mon, s.stats.pswapin,"pages_swapped_in" );
monitor.c static void do_balloon(Monitor *mon, int value) · line 1614
Quoted 10 lines
monitor.c +9
-0+print_stat (mon, s.stats.pswapout,"pages_swapped_out" ); +print_stat (mon, s.stats.panon,"anon_pages" ); +print_stat (mon, s.stats.pgmajfault,"major_page_faults" ); +print_stat (mon, s.stats.pgminfault,"minor_page_faults" ); +print_stat (mon, s.stats.memfree,"free_memory" ); +print_stat (mon, s.stats.memtot,"total_memory" ); +monitor_printf (mon,"\n" ); + } + }
These days, would it make more sense to emit a QJSON object?
In this case the JSON object is quite human readable too.
-- Jamie
Quoted 3 lines · Jamie Lokier
These days, would it make more sense to emit a QJSON object?
In this case the JSON object is quite human readable too.
I'm not very particular on the output format since it's main consumer is likely another program. Is XML output via the monitor a new precedent in qemu? I was unable to find any other monitor command that emits XML.
Signature · 2 lines
Thanks, Adam