lib/memory.c

   1 /*
   2  * Copyright (c) 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "memory.h"
  19 #include <stdbool.h>
  20 #include <sys/time.h>
  21 #include <sys/resource.h>
  22 #include "dynamic-string.h"
  23 #include "poll-loop.h"
  24 #include "simap.h"
  25 #include "timeval.h"
  26 #include "unixctl.h"
  27 #include "vlog.h"
  28
  29 VLOG_DEFINE_THIS_MODULE(memory);
  30
  31 /* The number of milliseconds before the first report of daemon memory usage,
  32  * and the number of milliseconds between checks for daemon memory growth.  */
  33 #define MEMORY_CHECK_INTERVAL (10 * 1000)
  34
  35 /* When we should next check memory usage and possibly trigger a report. */
  36 static long long int next_check;
  37
  38 /* The last time at which we reported memory usage, and the usage we reported
  39  * at that time. */
  40 static long long int last_report;
  41 static unsigned long int last_reported_maxrss;
  42
  43 /* Are we expecting a call to memory_report()? */
  44 static bool want_report;
  45
  46 /* Unixctl connections waiting for responses. */
  47 static struct unixctl_conn **conns;
  48 static size_t n_conns;
  49
  50 static void memory_init(void);
  51
  52 /* Runs the memory monitor.
  53  *
  54  * The client should call memory_should_report() afterward.
  55  *
  56  * This function, and the remainder of this module's interface, should be
  57  * called from only a single thread. */
  58 void
  59 memory_run(void)
  60 {
  61     struct rusage usage;
  62     long long int now;
  63
  64     memory_init();
  65
  66     /* Time for a check? */
  67     now = time_msec();
  68     if (now < next_check) {
  69         return;
  70     }
  71     next_check = now + MEMORY_CHECK_INTERVAL;
  72
  73     /* Time for a report? */
  74     getrusage(RUSAGE_SELF, &usage);
  75     if (!last_reported_maxrss) {
  76         VLOG_INFO("%lu kB peak resident set size after %.1f seconds",
  77                   (unsigned long int) usage.ru_maxrss,
  78                   (now - time_boot_msec()) / 1000.0);
  79     } else if (usage.ru_maxrss >= last_reported_maxrss * 1.5) {
  80         VLOG_INFO("peak resident set size grew %.0f%% in last %.1f seconds, "
  81                   "from %lu kB to %lu kB",
  82                   ((double) usage.ru_maxrss / last_reported_maxrss - 1) * 100,
  83                   (now - last_report) / 1000.0,
  84                   last_reported_maxrss, (unsigned long int) usage.ru_maxrss);
  85     } else {
  86         return;
  87     }
  88
  89     /* Request a report. */
  90     want_report = true;
  91     last_report = now;
  92     last_reported_maxrss = usage.ru_maxrss;
  93 }
  94
  95 /* Causes the poll loop to wake up if the memory monitor needs to run. */
  96 void
  97 memory_wait(void)
  98 {
  99     if (memory_should_report()) {
 100         poll_immediate_wake();
 101     }
 102 }
 103
 104 /* Returns true if the caller should log some information about memory usage
 105  * (with memory_report()), false otherwise. */
 106 bool
 107 memory_should_report(void)
 108 {
 109     return want_report || n_conns > 0;
 110 }
 111
 112 static void
 113 compose_report(const struct simap *usage, struct ds *s)
 114 {
 115     const struct simap_node **nodes = simap_sort(usage);
 116     size_t n = simap_count(usage);
 117     size_t i;
 118
 119     for (i = 0; i < n; i++) {
 120         const struct simap_node *node = nodes[i];
 121
 122         ds_put_format(s, "%s:%u ", node->name, node->data);
 123     }
 124     ds_chomp(s, ' ');
 125     free(nodes);
 126 }
 127
 128 /* Logs the contents of 'usage', as a collection of name-count pairs.
 129  *
 130  * 'usage' should capture large-scale statistics that one might reasonably
 131  * expect to correlate with memory usage.  For example, each OpenFlow flow
 132  * requires some memory, so ovs-vswitchd includes the total number of flows in
 133  * 'usage'. */
 134 void
 135 memory_report(const struct simap *usage)
 136 {
 137     struct ds s;
 138     size_t i;
 139
 140     ds_init(&s);
 141     compose_report(usage, &s);
 142
 143     if (want_report) {
 144         if (s.length) {
 145             VLOG_INFO("%s", ds_cstr(&s));
 146         }
 147         want_report = false;
 148     }
 149     if (n_conns) {
 150         for (i = 0; i < n_conns; i++) {
 151             unixctl_command_reply(conns[i], ds_cstr(&s));
 152         }
 153         free(conns);
 154         conns = NULL;
 155         n_conns = 0;
 156     }
 157
 158     ds_destroy(&s);
 159 }
 160
 161 static void
 162 memory_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 163                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 164 {
 165     conns = xrealloc(conns, (n_conns + 1) * sizeof *conns);
 166     conns[n_conns++] = conn;
 167 }
 168
 169 static void
 170 memory_init(void)
 171 {
 172     static bool inited = false;
 173
 174     if (!inited) {
 175         inited = true;
 176         unixctl_command_register("memory/show", "", 0, 0,
 177                                  memory_unixctl_show, NULL);
 178
 179         next_check = time_boot_msec() + MEMORY_CHECK_INTERVAL;
 180     }
 181 }