Implement adaptive sleep time

The idea is simple: if memory and swap can only fill up so fast,
we know how long we can sleep without risking to miss a low
memory event.

#61

README.md

@@ -205,7 +205,10 @@ accept
 Changelog
 ---------
 * v1.2, in progress
- * Remove option to use kernel oom-killer (`-k`) ([issue #80](https://github.com/rfjakob/earlyoom/issues/80))
+ * Implement adaptive sleep time (= adaptive poll rate) to lower CPU
+ usage further ([issue #61](https://github.com/rfjakob/earlyoom/issues/61))
+ * Remove option to use kernel oom-killer (`-k`)
+ ([issue #80](https://github.com/rfjakob/earlyoom/issues/80))
 * v1.1, 2018-07-07
  * Fix possible shell code injection through GUI notifications
  ([commit](https://github.com/rfjakob/earlyoom/commit/ab79aa3895077676f50120f15e2bb22915446db9))

main.c

@@ -288,13 +288,45 @@ static int set_oom_score_adj(int oom_score_adj)
  return 0;
 }
 
+/* Calculate the time we should sleep based upon how far away from the memory and swap
+ * limits we are (headroom). Returns a millisecond value between 100 and 1000 (inclusive).
+ * The idea is simple: if memory and swap can only fill up so fast, we know how long we can sleep
+ * without risking to miss a low memory event.
+ */
+static int sleep_time_ms(const poll_loop_args_t* args, const meminfo_t* m)
+{
+ // Maximum expected memory/swap fill rate. In kiB per millisecond ==~ MiB per second.
+ const int mem_fill_rate = 6000; // 6000MiB/s seen with "stress -m 4 --vm-bytes 4G"
+ const int swap_fill_rate = 800; // 800MiB/s seen with membomb on ZRAM
+ // Clamp calculated value to this range (milliseconds)
+ const int min_sleep = 100;
+ const int max_sleep = 1000;
+
+ int mem_headroom_kib = (m->MemAvailablePercent - args->mem_min_percent) * 10 * m->MemTotalMiB;
+ if (mem_headroom_kib < 0) {
+ mem_headroom_kib = 0;
+ }
+ int swap_headroom_kib = (m->SwapFreePercent - args->swap_min_percent) * 10 * m->SwapTotalMiB;
+ if (swap_headroom_kib < 0) {
+ swap_headroom_kib = 0;
+ }
+ int ms = mem_headroom_kib / mem_fill_rate + swap_headroom_kib / swap_fill_rate;
+ if (ms < min_sleep) {
+ return min_sleep;
+ }
+ if (ms > max_sleep) {
+ return max_sleep;
+ }
+ return ms;
+}
+
 static void poll_loop(const poll_loop_args_t args)
 {
- meminfo_t m;
- int loop_cnt = 0;
- int tick_us = 100000; // 100 ms <=> 10 Hz
+ meminfo_t m = {0};
+ int report_countdown_ms = 0;
+ // extra time to sleep after a kill
+ const int cooldown_ms = 200;
 
- int report_interval_cnts = args.report_interval_ms * 1000 / tick_us;
  while (1) {
  m = parse_meminfo();
 
@@ -316,14 +348,18 @@ static void poll_loop(const poll_loop_args_t args)
  // (Yes, this will sleep even if the kill has failed. Does no harm and keeps the
  // code simple.)
  if (m.SwapTotalMiB > 0) {
- int sleep_cycles = 2;
- usleep(sleep_cycles * tick_us);
- loop_cnt += sleep_cycles;
+ usleep(cooldown_ms*1000);
+ report_countdown_ms -= cooldown_ms;
  }
- } else if (args.report_interval_ms > 0 && loop_cnt % report_interval_cnts == 0) {
+ } else if (args.report_interval_ms && report_countdown_ms <= 0) {
  print_mem_stats(stdout, m);
+ report_countdown_ms = args.report_interval_ms;
+ }
+ int sleep_ms = sleep_time_ms(&args, &m);
+ if (enable_debug) {
+ printf("adaptive sleep time: %d ms\n", sleep_ms);
  }
- usleep(tick_us);
- loop_cnt++;
+ usleep(sleep_ms*1000);
+ report_countdown_ms -= sleep_ms;
  }
 }