Double-check free memory after selecting victim pid

The run time of find_largest_process is proportional to the number
of processes, and takes 2.5ms on my box with a running Gnome desktop (try "make bench").
This is long enough that the situation may have changed in the meantime,
so we double-check if we still need to kill anything.
The run time of parse_meminfo is only 6us on my box and independent of the number
of processes (try "make bench").

Fixes #205

main.c

@@ -381,29 +381,53 @@ static unsigned sleep_time_ms(const poll_loop_args_t* args, const meminfo_t* m)
     return (unsigned)ms;
 }
 
+/* lowmem_sig compares the limits with the current memory situation
+ * and returns which signal (SIGKILL, SIGTERM, 0) should be sent in
+ * response. 0 means that there is enough memory and we should
+ * not kill anything.
+ */
+static int lowmem_sig(const poll_loop_args_t* args, const meminfo_t* m) {
+    if (m->MemAvailablePercent <= args->mem_kill_percent && m->SwapFreePercent <= args->swap_kill_percent)
+        return SIGKILL;
+    else if (m->MemAvailablePercent <= args->mem_term_percent && m->SwapFreePercent <= args->swap_term_percent)
+        return SIGTERM;
+    return 0;
+}
+
+// poll_loop is the main event loop. Never returns.
 static void poll_loop(const poll_loop_args_t* args)
 {
     // Print a a memory report when this reaches zero. We start at zero so
     // we print the first report immediately.
     int report_countdown_ms = 0;
 
     while (1) {
-        int sig = 0;
         meminfo_t m = parse_meminfo();
-        if (m.MemAvailablePercent <= args->mem_kill_percent && m.SwapFreePercent <= args->swap_kill_percent) {
+        int sig = lowmem_sig(args, &m);
+        if (sig == SIGKILL) {
             print_mem_stats(warn, m);
             warn("low memory! at or below SIGKILL limits: mem " PRIPCT ", swap " PRIPCT "\n",
                 args->mem_kill_percent, args->swap_kill_percent);
-            sig = SIGKILL;
-        } else if (m.MemAvailablePercent <= args->mem_term_percent && m.SwapFreePercent <= args->swap_term_percent) {
+        } else if (sig == SIGTERM) {
             print_mem_stats(warn, m);
             warn("low memory! at or below SIGTERM limits: mem " PRIPCT ", swap " PRIPCT "\n",
                 args->mem_term_percent, args->swap_term_percent);
-            sig = SIGTERM;
         }
         if (sig) {
             procinfo_t victim = find_largest_process(args);
-            kill_process(args, sig, victim);
+            /* The run time of find_largest_process is proportional to the number
+             * of processes, and takes 2.5ms on my box with a running Gnome desktop (try "make bench").
+             * This is long enough that the situation may have changed in the meantime,
+             * so we double-check if we still need to kill anything.
+             * The run time of parse_meminfo is only 6us on my box and independent of the number
+             * of processes (try "make bench").
+             */
+            m = parse_meminfo();
+            if(lowmem_sig(args, &m) == 0) {
+                warn("memory situation has recovered while selecting victim\n");
+            } else {
+                kill_process(args, sig, victim);
+            }
         } else if (args->report_interval_ms && report_countdown_ms <= 0) {
             print_mem_stats(printf, m);
             report_countdown_ms = args->report_interval_ms;