cfm: Minor whitespace cleanup.
[openvswitch] / lib / memory.c
1 /*
2  * Copyright (c) 2012 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 void
56 memory_run(void)
57 {
58     struct rusage usage;
59     long long int now;
60
61     memory_init();
62
63     /* Time for a check? */
64     now = time_msec();
65     if (now < next_check) {
66         return;
67     }
68     next_check = now + MEMORY_CHECK_INTERVAL;
69
70     /* Time for a report? */
71     getrusage(RUSAGE_SELF, &usage);
72     if (!last_reported_maxrss) {
73         VLOG_INFO("%lu kB peak resident set size after %.1f seconds",
74                   (unsigned long int) usage.ru_maxrss,
75                   (now - time_boot_msec()) / 1000.0);
76     } else if (usage.ru_maxrss >= last_reported_maxrss * 1.5) {
77         VLOG_INFO("peak resident set size grew %.0f%% in last %.1f seconds, "
78                   "from %lu kB to %lu kB",
79                   ((double) usage.ru_maxrss / last_reported_maxrss - 1) * 100,
80                   (now - last_report) / 1000.0,
81                   last_reported_maxrss, (unsigned long int) usage.ru_maxrss);
82     } else {
83         return;
84     }
85
86     /* Request a report. */
87     want_report = true;
88     last_report = now;
89     last_reported_maxrss = usage.ru_maxrss;
90 }
91
92 /* Causes the poll loop to wake up if the memory monitor needs to run. */
93 void
94 memory_wait(void)
95 {
96     if (memory_should_report()) {
97         poll_immediate_wake();
98     }
99 }
100
101 /* Returns true if the caller should log some information about memory usage
102  * (with memory_report()), false otherwise. */
103 bool
104 memory_should_report(void)
105 {
106     return want_report || n_conns > 0;
107 }
108
109 static void
110 compose_report(const struct simap *usage, struct ds *s)
111 {
112     const struct simap_node **nodes = simap_sort(usage);
113     size_t n = simap_count(usage);
114     size_t i;
115
116     for (i = 0; i < n; i++) {
117         const struct simap_node *node = nodes[i];
118
119         ds_put_format(s, "%s:%u ", node->name, node->data);
120     }
121     ds_chomp(s, ' ');
122     free(nodes);
123 }
124
125 /* Logs the contents of 'usage', as a collection of name-count pairs.
126  *
127  * 'usage' should capture large-scale statistics that one might reasonably
128  * expect to correlate with memory usage.  For example, each OpenFlow flow
129  * requires some memory, so ovs-vswitchd includes the total number of flows in
130  * 'usage'. */
131 void
132 memory_report(const struct simap *usage)
133 {
134     struct ds s;
135     size_t i;
136
137     ds_init(&s);
138     compose_report(usage, &s);
139
140     if (want_report) {
141         VLOG_INFO("%s", ds_cstr(&s));
142         want_report = false;
143     }
144     if (n_conns) {
145         for (i = 0; i < n_conns; i++) {
146             unixctl_command_reply(conns[i], ds_cstr(&s));
147         }
148         free(conns);
149         conns = NULL;
150         n_conns = 0;
151     }
152
153     ds_destroy(&s);
154 }
155
156 static void
157 memory_unixctl_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
158                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
159 {
160     conns = xrealloc(conns, (n_conns + 1) * sizeof *conns);
161     conns[n_conns++] = conn;
162 }
163
164 static void
165 memory_init(void)
166 {
167     static bool inited = false;
168
169     if (!inited) {
170         inited = true;
171         unixctl_command_register("memory/show", "", 0, 0,
172                                  memory_unixctl_show, NULL);
173
174         next_check = time_boot_msec() + MEMORY_CHECK_INTERVAL;
175     }
176 }