Rolling statistics utilities

new file mode 100644
index 0000000..59b9f79
@@ -0,0 +1,87 @@
+/*
+ * A container for statistics that are measured repeatedly.
+ *
+ * Copyright 2015 Red Hat, Inc. and/or its affiliates
+ *
+ * Authors:
+ *   Dr. David Alan Gilbert <[email protected]>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef __QEMU_ROLLING_STATS_H
+#define __QEMU_ROLLING_STATS_H 1
+
+#include "qemu/typedefs.h"
+/**
+ * Allocate and initialise an 'RStats' structure.
+ *
+ * @len:    Number of values to hold
+ * @weight: Weight for the weighted average, between 0..1
+ *          smaller values cause the average to update more quickly.
+ *
+ * Returns: A pointer to the RStats structure.
+ */
+RStats *rstats_init(size_t len, double weight);
+
+/**
+ * Deallocate the RStats structure
+ */
+void rstats_destroy(RStats *r);
+
+/**
+ * Add a new value into the RStats record.
+ *
+ * @r: The RStats to update
+ * @value: The new value to be recorded
+ * @tag: A tag to be associated with the value, not used by the calculations
+ *       (e.g. a time or iteration count)
+ */
+void rstats_add_value(RStats *r, double value, uint64_t tag);
+
+/**
+ * Reset the RStats structure
+ *
+ */
+void rstats_reset(RStats *r);
+
+/**
+ * Returns a freshly allocated 'RollingStats' qapi object containg the data from
+ * the RStats.  The data is copied out under lock, but then the caller can
+ * access the RollingStats without needing a lock.  The caller should free
+ * the RollingStats.
+ *
+ * @r: The RStats to copy
+ *
+ * Returns: a RollingStats that should be freed by the caller
+ */
+RollingStats *rstats_as_RollingStats(RStats *r);
+
+/**
+ * Return the mean
+ * @r: The RStats to examine
+ *
+ * Returns: The mean value
+ */
+double rstats_get_mean(const RStats *r);
+
+/**
+ * Return the weighted mean
+ * @r: The RStats to examine
+ *
+ * Returns: The weighted mean
+ */
+double rstats_get_weighted_mean(const RStats *r);
+
+/**
+ * Return the minimum and maximum values
+ * @r: The RStats to examine
+ * @min: Pointer to return the minimum in
+ * @max: Pointer to return the maximum in
+ *
+ */
+void rstats_get_min_max(const RStats *r, double *min, double *max);
+
+#endif

index cde3314..3488dfd 100644
@@ -69,6 +69,7 @@ typedef struct QEMUSizedBuffer QEMUSizedBuffer;
 typedef struct QEMUTimerListGroup QEMUTimerListGroup;
 typedef struct QEMUTimer QEMUTimer;
 typedef struct Range Range;
+typedef struct RStats RStats;
 typedef struct SerialState SerialState;
 typedef struct SHPCDevice SHPCDevice;
 typedef struct SMBusDevice SMBusDevice;

236 lines not on this page · raw message

index 735097c..20241d8 100644
@@ -138,6 +138,27 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
     qapi_free_MouseInfoList(mice_list);
 }
 
+__attribute__ (( unused )) /* Until later in patch series */
+static void monitor_printf_RollingStats(Monitor *mon, const char *title,
+                                        RollingStats *r)
+{
+    RollingStatsValueList *list_entry = r->values;
+
+    monitor_printf(mon, "%s: Min/Max: %.8g, %.8g Mean: %.8g "
+                        "(Weighted: %.8g) Count: %" PRIu64
+                        " Values: ",
+                   title, r->min, r->max, r->mean, r->weighted_mean, r->count);
+
+    while (list_entry) {
+        monitor_printf(mon, "%.8g@%" PRIu64 "%s",
+                       list_entry->value->value,
+                       list_entry->value->tag,
+                       list_entry->next ? ", " : "");
+        list_entry = list_entry->next;
+    }
+    monitor_printf(mon, "\n");
+}
+
 void hmp_info_migrate(Monitor *mon, const QDict *qdict)
 {
     MigrationInfo *info;

index 20241d8..6bd19b2 100644
@@ -138,7 +138,6 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict)
     qapi_free_MouseInfoList(mice_list);
 }
 
-__attribute__ (( unused )) /* Until later in patch series */
 static void monitor_printf_RollingStats(Monitor *mon, const char *title,
                                         RollingStats *r)
 {

@@ -186,6 +185,10 @@ void hmp_info_migrate(Monitor *mon, const QDict *qdict)
             monitor_printf(mon, "expected downtime: %" PRIu64 " milliseconds\n",
                            info->expected_downtime);
         }
+        if (info->has_expected_downtime_stats) {
+            monitor_printf_RollingStats(mon, "expected downtime stats",
+                           info->expected_downtime_stats);
+        }
         if (info->has_downtime) {
             monitor_printf(mon, "downtime: %" PRIu64 " milliseconds\n",
                            info->downtime);

index 703b7d7..b37ec0c 100644
@@ -63,6 +63,7 @@ struct MigrationState
     int64_t xbzrle_cache_size;
     int64_t setup_time;
     int64_t dirty_sync_count;
+    RStats *expected_downtime_stats;
 };
 
 void process_incoming_migration(QEMUFile *f);

index b3adbc6..4041823 100644
@@ -24,6 +24,7 @@
 #include "migration/block.h"
 #include "qemu/thread.h"
 #include "qmp-commands.h"
+#include "qemu/rolling-stats.h"
 #include "trace.h"
 
 enum {

@@ -201,6 +202,9 @@ MigrationInfo *qmp_query_migrate(Error **errp)
             - s->total_time;
         info->has_expected_downtime = true;
         info->expected_downtime = s->expected_downtime;
+        info->expected_downtime_stats =
+            rstats_as_RollingStats(s->expected_downtime_stats);
+        info->has_expected_downtime_stats = true;
         info->has_setup_time = true;
         info->setup_time = s->setup_time;
 

@@ -238,6 +242,9 @@ MigrationInfo *qmp_query_migrate(Error **errp)
         info->downtime = s->downtime;
         info->has_setup_time = true;
         info->setup_time = s->setup_time;
+        info->expected_downtime_stats =
+            rstats_as_RollingStats(s->expected_downtime_stats);
+        info->has_expected_downtime_stats = true;
 
         info->has_ram = true;
         info->ram = g_malloc0(sizeof(*info->ram));

@@ -389,12 +396,18 @@ static MigrationState *migrate_init(const MigrationParams *params)
     memcpy(enabled_capabilities, s->enabled_capabilities,
            sizeof(enabled_capabilities));
 
+    /* Resets the current state */
     memset(s, 0, sizeof(*s));
     s->params = *params;
     memcpy(s->enabled_capabilities, enabled_capabilities,
            sizeof(enabled_capabilities));
     s->xbzrle_cache_size = xbzrle_cache_size;
 
+    if (!s->expected_downtime_stats) {
+        s->expected_downtime_stats = rstats_init(5, 0.2);
+    } else {
+        rstats_reset(s->expected_downtime_stats);
+    }
     s->bandwidth_limit = bandwidth_limit;
     s->state = MIG_STATE_SETUP;
     trace_migrate_set_state(MIG_STATE_SETUP);

@@ -658,6 +671,8 @@ static void *migration_thread(void *opaque)
                10000 is a small enough number for our purposes */
             if (s->dirty_bytes_rate && transferred_bytes > 10000) {
                 s->expected_downtime = s->dirty_bytes_rate / bandwidth;
+                rstats_add_value(s->expected_downtime_stats,
+                                 s->expected_downtime, current_time);
             }
 
             qemu_file_reset_rate_limit(s->file);