diff -rup numad-0.5git/numad.8 numad-0.5git-new/numad.8

--- numad-0.5git/numad.8	2012-12-03 15:40:40.000000000 +0100

+++ numad-0.5git-new/numad.8	2016-08-30 08:45:19.000000000 +0200

@@ -1,45 +1,56 @@

 .TH "numad" "8" "1.0.0" "Bill Gray" "Administration"

-.SH "numad"

-.LP 

+.SH "NAME"

+.LP

 numad \- A user\-level daemon that provides placement advice and process

 management for efficient use of CPUs and memory on systems with NUMA topology.

-.SH "SYNTAX"

-.LP 

+.SH "SYNOPSIS"

+.LP

 numad [\fI\-dhvV\fP]

-.br 

-.LP 

-numad  [\fI\-D non-standard-cgroup-mount-point\fP]

-.br 

-.LP 

+.br

+.LP

+numad  [\fI\-C 0|1\fP]

+.br

+.LP

+numad  [\fI\-H THP_hugepage_scan_sleep_ms\fP]

+.br

+.LP

 numad  [\fI\-i [min_interval:]max_interval\fP]

-.br 

-.LP 

+.br

+.LP

 numad  [\fI\-K 0|1\fP]

-.br 

-.LP 

+.br

+.LP

 numad  [\fI\-l log_level\fP]

-.br 

-.LP 

+.br

+.LP

+numad  [\fI\-m target_memory_locality\fP]

+.br

+.LP

 numad  [\fI\-p PID\fP]

-.br 

-.LP 

+.br

+.LP

 numad  [\fI\-r PID\fP]

-.br 

-.LP 

+.br

+.LP

+numad  [\fI\-R reserved-CPU-list\fP]

+.br

+.LP

 numad  [\fI\-S 0|1\fP]

-.br 

-.LP 

+.br

+.LP

+numad  [\fI\-t logical_CPU_percent\fP]

+.br

+.LP

 numad  [\fI\-u target_utilization\fP]

-.br 

-.LP 

+.br

+.LP

 numad  [\fI\-w NCPUS[:MB]\fP]

-.br 

-.LP 

+.br

+.LP

 numad  [\fI\-x PID\fP]

-.br 

-

+.br

 .SH "DESCRIPTION"

-.LP 

+.LP

 Numad is a system daemon that monitors NUMA topology and resource usage. It

 will attempt to locate processes for efficient NUMA locality and affinity,

 dynamically adjusting to changing system conditions.  Numad also provides

@@ -53,25 +64,42 @@ large in-memory database application, fo

 accesses will likely remain unpredictable -- numad will probably not improve

 performance.

 .SH "OPTIONS"

-.LP 

-.TP 

+.LP

+.TP

+\fB\-C\fR <\fI0|1\fP>

+This option controls whether or not numad treats inactive file cache as

+available memory. By default, numad assumes it can count inactive file cache as

+"free" memory when considering resources to match with processes.  Specify

+\fI\-C 0\fP if numad should instead consider inactive file cache as a consumed

+resource.

+.TP

 \fB\-d\fR

 Debug output in log, sets the log level to LOG_DEBUG.  Same effect as \fI\-l 7\fP.

 .TP

-\fB\-D\fR <\fInon-standard-cgroup-mount-point\fP>

-This option can be used to communicate a non-standard cgroup mount point to

-numad.  This is not normally necessary.

-.TP 

 \fB\-h\fR

 Display usage help information and then exit.

-.TP 

+.TP

+\fB\-H\fR  <\fITHP_scan_sleep_ms\fP>

+Set the desired transparent hugepage scan interval in ms.  The

+.na

+/sys/kernel/mm/tranparent_hugepage/khugepaged/scan_sleep_millisecs

+.ad

+tunable is usually set to 10000ms by the operating system.  The default is

+changed by numad to be 1000ms since it is helpful for the hugepage daemon to be

+more aggressive when memory moves between nodes.  Specifying (\fI\-H 0\fP) will

+cause numad to retain the system default value.  You can also make the hugepage

+daemon more or less aggressive by specifying an alternate value with this

+option.  For example, setting this value to 100ms (\fI\-H 100\fP) might improve

+the performance of workloads which use many transparent hugepages.

+.TP

 \fB\-i\fR <\fI[min_interval:]max_interval\fP>

 Sets the time interval that numad waits between system scans, in seconds to

 <\fImax_interval\fP>. Default <\fImax_interval\fP> is 15 seconds, default

 <\fImin_interval\fP> is 5 seconds.  Setting a <\fImax_interval\fP> of zero will

 cause the daemon to exit.  (This is the normal mechanism to terminate the

 daemon.)  A bigger <\fImax_interval\fP> will decrease numad overhead but also

-decrease responsiveness to changing loads.

+decrease responsiveness to changing loads.  The default numad max_interval can

+be changed in the numad.conf file.

 .TP

 \fB\-K\fR <\fI0|1\fP>

 This option controls whether numad keeps interleaved memory spread across NUMA

@@ -82,10 +110,24 @@ a large, single-instance application tha

 the workload will have continuous unpredictable memory access patterns (e.g. a

 large in-memory database), you might get better results by specifying \fI\-K

 1\fP to instruct numad to keep interleaved memory distributed.

-.TP 

+.TP

 \fB\-l\fR <\fIlog_level\fP>

 Sets the log level to <\fIlog_level\fP>.  Reasonable choices are 5, 6, or 7.

-The default value is 5.

+The default value is 5.  Note that CPU values are scaled by a factor of 100

+internally and in the numad log files.  Unfortunately, you don't actually have

+that many CPUs.

+.TP

+\fB\-m\fR  <\fItarget_memory_locality\fP>

+Set the desired memory locality threshold to stop moving process memory.  Numad

+might stop retrying to coalesce process memory when more than this percentage

+of the process's memory is already localized in the target node(s).  The

+default is 90%. Numad will frequently localize more than the localization

+threshold percent, but it will not necessarily do so.  Decrease the threshold

+to allow numad to leave more process memory distributed on various nodes.

+Increase the threshold to instruct numad to try to localize more memory.

+Acceptable values are between 50 and 100 percent.  Note that setting the target

+memory locality to 100% might cause numad to continually retry to move memory

+that the kernel will never succesfully move.

 .TP

 \fB\-p\fR <\fIPID\fP>

 Add PID to explicit inclusion list of processes to consider for managing, if

@@ -102,6 +144,12 @@ processes.  After daemon start, only one

 process lists per subsequent numad invocation.  Use with \-S and \-p and \-x to

 precisely control the scope of processes numad can manage.

 .TP

+\fB\-R\fR <\fICPU_LIST\fP>

+Specify a list of CPUs that numad should assume are reserved for non-numad use.

+No processes will be bound to the specified CPUs by numad.  This option is

+effective only when starting numad.  You cannot change reserved CPUs

+dynamically while numad is already running.

+.TP

 \fB\-S\fR <\fI0|1\fP>

 This option controls whether numad scans all system processes or only the

 processes on the explicit inclusion PID list.  The default is to scan all

@@ -113,18 +161,30 @@ exclusion list).  Starting numad as

 .br

 will limit scanning, and thus also automatic NUMA management, to only those

 three explicitly specified processes.

-.TP 

+.TP

+\fB\-t\fR  <\fIlogical_CPU_percent\fP>

+Specify the resource value of logical CPUs.  Hardware threads typically share

+most core resources, and so logical CPUs add only a fraction of CPU power for

+many workloads.  By default numad considers logical CPUs to be only 20 percent

+of a dedicated hardware core.

+.TP

 \fB\-u\fR  <\fItarget_utilization\fP>

 Set the desired maximum consumption percentage of a node. Default is 85%.

 Decrease the target value to maintain more available resource margin on each

 node.  Increase the target value to more exhaustively consume node resources.

-.TP 

+If you have sized your workloads to precisely fit inside a NUMA node,

+specifying (\fI\-u 100\fP) might improve system performance by telling numad to

+go ahead and consume all the resources in each node.  It is possible to specify

+values up to 130 percent to oversubscribe CPUs in the nodes, but memory

+utilization is always capped at 100%.  Use oversubscription values very

+carefully.

+.TP

 \fB\-v\fR

 Verbose output in log, sets the log level to LOG_INFO.  Same effect as \fI\-l 6\fP.

-.TP 

+.TP

 \fB\-V\fR

 Display version information and exit.

-.TP 

+.TP

 \fB\-w\fR <\fINCPUS[:MB]\fP>

 Queries numad for the best NUMA nodes to bind an entity that needs

 <\fINCPUS\fP>.  The amount of memory (in MBs) is optional, but should normally

@@ -145,32 +205,37 @@ Add PID to explicit exclusion list of pr

 Multiple \fI\-x PID\fP options can be specified at daemon start, but after

 daemon start, only one PID can be added to the exclusion list per subsequent

 numad invocation.  Use with \-S to precisely control the scope of processes

-numad can manage.  

+numad can manage.

 .SH "FILES"

-.LP 

-\fI/usr/bin/numad\fP 

-.br 

-\fI/var/log/numad.log\fP 

-.br 

-\fI/var/run/numad.pid\fP 

+.LP

+\fI/usr/bin/numad\fP

+.br

+\fI/etc/numad.conf\fP

+.br

+\fI/var/log/numad.log\fP

+.br

+\fI/var/run/numad.pid\fP

 .SH "ENVIRONMENT VARIABLES"

-.LP 

-.TP 

+.LP

+.TP

 None.

 .SH "EXAMPLES"

-.LP 

-Numad is normally run as a system daemon and should be managed by the 

+.LP

+Numad can be run as a system daemon and can be managed by the

 standard init mechanisms of the host.

-.LP  

+.LP

 If interactive (manual) control is desired, you can start the daemon manually by typing:

-.LP 

+.LP

 /usr/bin/numad

 .LP

-Subsequent numad invocations while the daemon is running can be used to dynamically change run-time options.

+Subsequent numad invocations while the daemon is running can be used to dynamically change most run-time options.

+.LP

+You can terminate numad from running by typing:

+.LP

+/usr/bin/numad -i0

 .SH "AUTHORS"

-.LP 

+.LP

 Bill Gray <bgray@redhat.com>

 .SH "SEE ALSO"

-.LP 

+.LP

 numactl(8)

-

diff -rup numad-0.5git/numad.c numad-0.5git-new/numad.c

--- numad-0.5git/numad.c	2012-12-03 15:40:40.000000000 +0100

+++ numad-0.5git-new/numad.c	2016-08-30 08:45:19.000000000 +0200

@@ -19,7 +19,7 @@ Inc., 59 Temple Place, Suite 330, Boston

 */ 

-// Compile with: gcc -O -std=gnu99 -Wall -pthread -o numad numad.c -lrt

+// Compile with: gcc -std=gnu99 -g -Wall -pthread -o numad numad.c -lrt -lm

 #define _GNU_SOURCE

@@ -40,6 +40,10 @@ Inc., 59 Temple Place, Suite 330, Boston

 #include <stdio.h>

 #include <stdlib.h>

 #include <string.h>

+#include <time.h>

+#include <unistd.h>

+#include <values.h>

+

 #include <sys/ipc.h>

 #include <sys/mman.h>

 #include <sys/msg.h>

@@ -49,26 +53,16 @@ Inc., 59 Temple Place, Suite 330, Boston

 #include <sys/syslog.h>

 #include <sys/time.h>

 #include <sys/types.h>

-#include <time.h>

-#include <unistd.h>

-#include <values.h>

+

+#include <asm/unistd.h>

-#define VERSION_STRING "20121130"

+#define VERSION_STRING "20150602"

 #define VAR_RUN_FILE "/var/run/numad.pid"

 #define VAR_LOG_FILE "/var/log/numad.log"

-char *cpuset_dir = NULL;

-char *cpuset_dir_list[] =  {

-    NULL,

-    "/sys/fs/cgroup/cpuset",

-    "/cgroup/cpuset",

-    NULL

-};

-

-

 #define KILOBYTE (1024)

 #define MEGABYTE (1024 * 1024)

@@ -86,14 +80,11 @@ char *cpuset_dir_list[] =  {

 #define MAX_INTERVAL 15

 #define CPU_THRESHOLD     50

 #define MEMORY_THRESHOLD 300

-#define TARGET_UTILIZATION_PERCENT 85

-#define IMPROVEMENT_THRESHOLD_PERCENT 5

-

+#define DEFAULT_HTT_PERCENT 20

+#define DEFAULT_THP_SCAN_SLEEP_MS 1000

+#define DEFAULT_UTILIZATION_PERCENT 85

+#define DEFAULT_MEMLOCALITY_PERCENT 90

-#define ELIM_NEW_LINE(s) \

-    if (s[strlen(s) - 1] == '\n') { \

-        s[strlen(s) - 1] = '\0'; \

-    }

 #define CONVERT_DIGITS_TO_NUM(p, n) \

     n = *p++ - '0'; \

@@ -105,19 +96,36 @@ char *cpuset_dir_list[] =  {

 int num_cpus = 0;

 int num_nodes = 0;

-int page_size_in_bytes = 0;

-int huge_page_size_in_bytes = 0;

+int threads_per_core = 0;

+uint64_t page_size_in_bytes = 0;

+uint64_t huge_page_size_in_bytes = 0;

 int min_interval = MIN_INTERVAL;

 int max_interval = MAX_INTERVAL;

-int target_utilization  = TARGET_UTILIZATION_PERCENT;

+int htt_percent = DEFAULT_HTT_PERCENT;

+int thp_scan_sleep_ms = DEFAULT_THP_SCAN_SLEEP_MS;

+int target_utilization  = DEFAULT_UTILIZATION_PERCENT;

+int target_memlocality  = DEFAULT_MEMLOCALITY_PERCENT;

 int scan_all_processes = 1;

 int keep_interleaved_memory = 0;

+int use_inactive_file_cache = 1;

 pthread_mutex_t pid_list_mutex;

 pthread_mutex_t node_info_mutex;

+long sum_CPUs_total = 0;

 int requested_mbs = 0;

 int requested_cpus = 0;

+int got_sighup = 0;

+int got_sigterm = 0;

+int got_sigquit = 0;

+

+void sig_handler(int signum) { 

+    switch (signum) {

+        case SIGHUP:  got_sighup  = 1; break;

+        case SIGTERM: got_sigterm = 1; break;

+        case SIGQUIT: got_sigquit = 1; break;

+    }

+}

@@ -139,7 +147,7 @@ void numad_log(int level, const char *fm

     }

     char buf[BUF_SIZE];

     time_t ts = time(NULL);

-    sprintf(buf, ctime(&ts);;

+    strncpy(buf, ctime(&ts), sizeof(buf));

     char *p = &buf[strlen(buf) - 1];

     *p++ = ':';

     *p++ = ' ';

@@ -155,13 +163,16 @@ void open_log_file() {

     log_fs = fopen(VAR_LOG_FILE, "a");

     if (log_fs == NULL) {

         log_fs = stderr;

-        numad_log(LOG_ERR, "Cannot open numad log file -- using stderr\n");

+        numad_log(LOG_ERR, "Cannot open numad log file (errno: %d) -- using stderr\n", errno);

     }

 }

+

 void close_log_file() {

     if (log_fs != NULL) {

-        fclose(log_fs);

+        if (log_fs != stderr) {

+            fclose(log_fs);

+        }

         log_fs = NULL;

     }

 }

@@ -235,23 +246,32 @@ void send_msg(long dst_pid, long cmd, lo

 typedef struct id_list {

-    // Use CPU_SET(3) <sched.h> cpuset bitmasks,

+    // Use CPU_SET(3) <sched.h> bitmasks,

     // but bundle size and pointer together

     // and genericize for both CPU and Node IDs

     cpu_set_t *set_p; 

     size_t bytes;

 } id_list_t, *id_list_p;

-#define INIT_ID_LIST(list_p) \

+#define ID_LIST_SET_P(list_p) (list_p->set_p)

+#define ID_LIST_BYTES(list_p) (list_p->bytes)

+

+#define INIT_ID_LIST(list_p, num_elements) \

     list_p = malloc(sizeof(id_list_t)); \

     if (list_p == NULL) { numad_log(LOG_CRIT, "INIT_ID_LIST malloc failed\n"); exit(EXIT_FAILURE); } \

-    list_p->set_p = CPU_ALLOC(num_cpus); \

+    list_p->set_p = CPU_ALLOC(num_elements); \

     if (list_p->set_p == NULL) { numad_log(LOG_CRIT, "CPU_ALLOC failed\n"); exit(EXIT_FAILURE); } \

-    list_p->bytes = CPU_ALLOC_SIZE(num_cpus);

+    list_p->bytes = CPU_ALLOC_SIZE(num_elements);

-#define CLEAR_LIST(list_p) \

+#define CLEAR_CPU_LIST(list_p) \

     if (list_p == NULL) { \

-        INIT_ID_LIST(list_p); \

+        INIT_ID_LIST(list_p, num_cpus); \

+    } \

+    CPU_ZERO_S(list_p->bytes, list_p->set_p)

+

+#define CLEAR_NODE_LIST(list_p) \

+    if (list_p == NULL) { \

+        INIT_ID_LIST(list_p, num_nodes); \

     } \

     CPU_ZERO_S(list_p->bytes, list_p->set_p)

@@ -262,6 +282,9 @@ typedef struct id_list {

         list_p = NULL; \

     }

+#define COPY_LIST(orig_list_p, copy_list_p) \

+    memcpy(copy_list_p->set_p, orig_list_p->set_p, orig_list_p->bytes)

+

 #define NUM_IDS_IN_LIST(list_p)     CPU_COUNT_S(list_p->bytes, list_p->set_p)

 #define ADD_ID_TO_LIST(k, list_p)  CPU_SET_S(k, list_p->bytes, list_p->set_p)

 #define CLR_ID_IN_LIST(k, list_p)  CPU_CLR_S(k, list_p->bytes, list_p->set_p)

@@ -272,6 +295,25 @@ typedef struct id_list {

 #define  OR_LISTS( or_list_p, list_1_p, list_2_p)  CPU_OR_S( or_list_p->bytes,  or_list_p->set_p, list_1_p->set_p, list_2_p->set_p)

 #define XOR_LISTS(xor_list_p, list_1_p, list_2_p) CPU_XOR_S(xor_list_p->bytes, xor_list_p->set_p, list_1_p->set_p, list_2_p->set_p)

+int negate_cpu_list(id_list_p list_p) {

+    if (list_p == NULL) {

+        numad_log(LOG_CRIT, "Cannot negate a NULL list\n");

+        exit(EXIT_FAILURE);

+    }

+    if (num_cpus < 1) {

+        numad_log(LOG_CRIT, "No CPUs to negate in list!\n");

+        exit(EXIT_FAILURE);

+    }

+    for (int ix = 0;  (ix < num_cpus);  ix++) {

+        if (ID_IS_IN_LIST(ix, list_p)) {

+            CLR_ID_IN_LIST(ix, list_p);

+        } else {

+            ADD_ID_TO_LIST(ix, list_p);

+        }

+    }

+    return NUM_IDS_IN_LIST(list_p);

+}

+

 int add_ids_to_list_from_str(id_list_p list_p, char *s) {

     if (list_p == NULL) {

         numad_log(LOG_CRIT, "Cannot add to NULL list\n");

@@ -352,9 +394,21 @@ typedef struct node_data {

     uint8_t *distance;

     id_list_p cpu_list_p; 

 } node_data_t, *node_data_p;

-

 node_data_p node = NULL;

+int min_node_CPUs_free_ix = -1;

+int min_node_MBs_free_ix = -1;

+long min_node_CPUs_free = MAXINT;

+long min_node_MBs_free = MAXINT;

+long max_node_CPUs_free = 0;

+long max_node_MBs_free = 0;

+long avg_node_CPUs_free = 0;

+long avg_node_MBs_free = 0;

+double stddev_node_CPUs_free = 0.0;

+double stddev_node_MBs_free = 0.0;

+

+

+

 // RING_BUF_SIZE must be a power of two

 #define RING_BUF_SIZE 8

@@ -366,14 +420,15 @@ typedef struct process_data {

     uint64_t data_time_stamp; // hundredths of seconds

     uint64_t bind_time_stamp;

     uint64_t num_threads;

+    uint64_t MBs_size;

     uint64_t MBs_used;

     uint64_t cpu_util;

     uint64_t CPUs_used;  // scaled * ONE_HUNDRED

     uint64_t CPUs_used_ring_buf[RING_BUF_SIZE];

     int ring_buf_ix;

-    int dup_bind_count;

     char *comm;

-    char *cpuset_name;

+    id_list_p node_list_p;

+    uint64_t *process_MBs;

 } process_data_t, *process_data_p;

@@ -433,7 +488,8 @@ int process_hash_insert(int pid) {

 }

 int process_hash_update(process_data_p newp) {

-    // This updates hash table stats for processes we are monitoring

+    // This updates hash table stats for processes we are monitoring. Only the

+    // scalar resource consumption stats need to be updated here.

     int new_hash_table_entry = 1;

     int ix = process_hash_insert(newp->pid);

     if (ix >= 0) {

@@ -460,6 +516,7 @@ int process_hash_update(process_data_p n

             }

             p->comm = strdup(newp->comm);

         }

+        p->MBs_size = newp->MBs_size;

         p->MBs_used = newp->MBs_used;

         p->cpu_util = newp->cpu_util;

         p->num_threads = newp->num_threads;

@@ -468,6 +525,11 @@ int process_hash_update(process_data_p n

     return new_hash_table_entry;

 }

+void process_hash_clear_all_bind_time_stamps() {

+    for (int ix = 0;  (ix < process_hash_table_size);  ix++) {

+        process_hash_table[ix].bind_time_stamp = 0;

+    }

+}

 int process_hash_rehash(int old_ix) {

     // Given the index of a table entry that would otherwise be orphaned by

@@ -489,7 +551,8 @@ int process_hash_remove(int pid) {

         // remove the target

         process_data_p dp = &process_hash_table[ix];

         if (dp->comm) { free(dp->comm); }

-        if (dp->cpuset_name) { free(dp->cpuset_name); }

+        if (dp->process_MBs) { free(dp->process_MBs); }

+        FREE_LIST(dp->node_list_p);

         memset(dp, 0, sizeof(process_data_t));

         // bubble up the collision chain and rehash if neeeded

         for (;;) {

@@ -543,15 +606,15 @@ void process_hash_table_dump() {

         process_data_p p = &process_hash_table[ix];

         if (p->pid) {

             numad_log(LOG_DEBUG,

-                "ix: %d  PID: %d %s  Thds: %d  CPU %ld  MBs: %ld Data TS: %ld  Bind TS: %ld\n",

+                "ix: %d  PID: %d %s  Thds: %d  CPU %ld  MBs: %ld/%ld Data TS: %ld  Bind TS: %ld\n",

                 ix, p->pid, ((p->comm != NULL) ? p->comm : "(Null)"), p->num_threads,

-                p->CPUs_used, p->MBs_used, p->data_time_stamp, p->bind_time_stamp);

+                p->CPUs_used, p->MBs_used, p->MBs_size, p->data_time_stamp, p->bind_time_stamp);

+            // FIXME: make this dump every field, but this is not even currently used

         }

     }

 }

 void process_hash_table_cleanup(uint64_t update_time) {

-    int cpusets_removed = 0;

     int num_hash_entries_used = 0;

     for (int ix = 0;  (ix < process_hash_table_size);  ix++) {

         process_data_p p = &process_hash_table[ix];

@@ -562,34 +625,14 @@ void process_hash_table_cleanup(uint64_t

                 p->data_time_stamp = 0;

                 p->CPUs_used = 0;

                 // Check for dead pids and remove them...

-                char fname[FNAME_SIZE];

-                snprintf(fname, FNAME_SIZE, "/proc/%d", p->pid);

-                if (access(fname, F_OK) < 0) {

-                    // Seems dead.  Forget this pid -- after first checking 

-                    // and removing obsolete numad.PID cpuset directories.  

-                    snprintf(fname, FNAME_SIZE, "%s/numad.%d", cpuset_dir, p->pid);

-                    if (access(fname, F_OK) == 0) {

-                        numad_log(LOG_NOTICE, "Removing obsolete cpuset: %s\n", fname);

-                        int rc = rmdir(fname);

-                        if (rc >= 0) {

-                            cpusets_removed += 1;

-                        } else {

-                            numad_log(LOG_ERR, "bad cpuset rmdir\n");

-                            // exit(EXIT_FAILURE);

-                        }

-                    }

+                if ((kill(p->pid, 0) == -1) && (errno == ESRCH)) {

+                    // Seems dead.  Forget this pid

                     process_hash_remove(p->pid);

                     num_hash_entries_used -= 1;

                 }

             }

         }

     }

-    if (cpusets_removed > 0) {

-        // Expire all the duplicate bind counts so things will be re-evaluated sooner.

-        for (int ix = 0;  (ix < process_hash_table_size);  ix++) {

-            process_hash_table[ix].dup_bind_count = 0;

-        }

-    }

     // Keep hash table approximately half empty

     if ((num_hash_entries_used * 7) / 4 > process_hash_table_size) {

         process_hash_table_expand();

@@ -610,9 +653,7 @@ pid_list_p insert_pid_into_pid_list(pid_

     if (process_hash_table != NULL) {

         int hash_ix = process_hash_lookup(pid);

         if ((hash_ix >= 0) && (list_ptr == include_pid_list)) {

-            // Clear dup_bind_count and interleaved flag,

-            // in case user wants it to be re-evaluated soon

-            process_hash_table[hash_ix].dup_bind_count = 0;

+            // Clear interleaved flag, in case user wants it to be re-evaluated

             process_hash_table[hash_ix].flags &= ~PROCESS_FLAG_INTERLEAVED;

         }

     }

@@ -678,18 +719,23 @@ void print_version_and_exit(char *prog_n

 void print_usage_and_exit(char *prog_name) {

     fprintf(stderr, "Usage: %s <options> ...\n", prog_name);

+    fprintf(stderr, "-C 1  to count inactive file cache as available memory (default 1)\n");

+    fprintf(stderr, "-C 0  to count inactive file cache memory as unavailable (default 1)\n");

     fprintf(stderr, "-d for debug logging (same effect as '-l 7')\n");

-    fprintf(stderr, "-D <CGROUP_MOUNT_POINT> to specify cgroup mount point\n");

     fprintf(stderr, "-h to print this usage info\n");

+    fprintf(stderr, "-H <N> to set THP scan_sleep_ms (default %d)\n", DEFAULT_THP_SCAN_SLEEP_MS);

     fprintf(stderr, "-i [<MIN>:]<MAX> to specify interval seconds\n");

-    fprintf(stderr, "-K 1  to keep interleaved memory spread across nodes\n");

-    fprintf(stderr, "-K 0  to merge interleaved memory to local NUMA nodes\n");

-    fprintf(stderr, "-l <N> to specify logging level (usually 5, 6, or 7)\n");

+    fprintf(stderr, "-K 1  to keep interleaved memory spread across nodes (default 0)\n");

+    fprintf(stderr, "-K 0  to merge interleaved memory to local NUMA nodes (default 0)\n");

+    fprintf(stderr, "-l <N> to specify logging level (usually 5, 6, or 7 -- default 5)\n");

+    fprintf(stderr, "-m <N> to specify memory locality target percent (default %d)\n", DEFAULT_MEMLOCALITY_PERCENT);

     fprintf(stderr, "-p <PID> to add PID to inclusion pid list\n");

     fprintf(stderr, "-r <PID> to remove PID from explicit pid lists\n");

-    fprintf(stderr, "-S 1  to scan all processes\n");

-    fprintf(stderr, "-S 0  to scan only explicit PID list processes\n");

-    fprintf(stderr, "-u <N> to specify target utilization percent (default 85)\n");

+    fprintf(stderr, "-R <CPU_LIST> to reserve some CPUs for non-numad use\n");

+    fprintf(stderr, "-S 1  to scan all processes (default 1)\n");

+    fprintf(stderr, "-S 0  to scan only explicit PID list processes (default 1)\n");

+    fprintf(stderr, "-t <N> to specify thread / logical CPU valuation percent (default %d)\n", DEFAULT_HTT_PERCENT);

+    fprintf(stderr, "-u <N> to specify utilization target percent (default %d)\n", DEFAULT_UTILIZATION_PERCENT);

     fprintf(stderr, "-v for verbose  (same effect as '-l 6')\n");

     fprintf(stderr, "-V to show version info\n");

     fprintf(stderr, "-w <CPUs>[:<MBs>] for NUMA node suggestions\n");

@@ -698,62 +744,35 @@ void print_usage_and_exit(char *prog_nam

 }

-void check_prereqs(char *prog_name) {

-    // Verify cpusets are available on this system.

-    char **dir = &cpuset_dir_list[0];

-    if (*dir == NULL) { dir++; }

-    while (*dir != NULL) {

-        cpuset_dir = *dir;

-        char fname[FNAME_SIZE];

-        snprintf(fname, FNAME_SIZE, "%s/cpuset.cpus", cpuset_dir);

-        if (access(fname, F_OK) == 0) {

-            break;

-        }

-        dir++;

-    }

-    if (*dir == NULL) {

-        fprintf(stderr, "\n");

-        fprintf(stderr, "Are CPUSETs enabled on this system?\n");

-        fprintf(stderr, "They are required for %s to function.\n\n", prog_name);

-        fprintf(stderr, "Check manpage CPUSET(7). You might need to do something like:\n");

-        fprintf(stderr, "    # mkdir <DIRECTORY_MOUNT_POINT>\n");

-        fprintf(stderr, "    # mount cgroup -t cgroup -o cpuset <DIRECTORY_MOUNT_POINT>\n");

-        fprintf(stderr, "    where <DIRECTORY_MOUNT_POINT> is something like:\n");

-        dir = &cpuset_dir_list[0];

-        if (*dir == NULL) { dir++; }

-        while (*dir != NULL) {

-            fprintf(stderr, "      - %s\n", *dir);

-            dir++;

-        }

-        fprintf(stderr, "and then try again...\n");

-        fprintf(stderr, "Or, use '-D <DIRECTORY_MOUNT_POINT>' to specify the correct mount point\n");

-        fprintf(stderr, "\n");

-        exit(EXIT_FAILURE);

+void set_thp_scan_sleep_ms(int new_ms) {

+    if (new_ms < 1) {

+        // 0 means do not change the system default

+        return;

     }

-    // Check on THP scan sleep time.

-    char *thp_scan_fname = "/sys/kernel/mm/redhat_transparent_hugepage/khugepaged/scan_sleep_millisecs";

-    int fd = open(thp_scan_fname, O_RDONLY, 0);

+    char *thp_scan_fname = "/sys/kernel/mm/transparent_hugepage/khugepaged/scan_sleep_millisecs";

+    int fd = open(thp_scan_fname, O_RDWR, 0);

     if (fd >= 0) {

-        int ms;

         char buf[BUF_SIZE];

         int bytes = read(fd, buf, BUF_SIZE);

-        close(fd);

         if (bytes > 0) {

+            buf[bytes] = '\0';

+            int cur_ms;

             char *p = buf;

-            CONVERT_DIGITS_TO_NUM(p, ms);

-            if (ms > 150) {