fpm binding master and children processes to specific core(s).

rational is there is git snippets and similar floating around about how
to achieve this via command line.
So idea is to do it "natively" especially those above mostly
focus on linux whereas more platforms are cpu affinity capable.
For now at least, focusing on simple cases, one core id or a range.

Author: devnexen

configure.ac

@@ -403,6 +403,7 @@ pty.h \
 pwd.h \
 resolv.h \
 strings.h \
+sched.h \
 syslog.h \
 sysexits.h \
 sys/ioctl.h \
@@ -605,6 +606,7 @@ poll \
 pthread_jit_write_protect_np \
 putenv \
 scandir \
+sched_setaffinity \
 setitimer \
 setenv \
 shutdown \

sapi/fpm/fpm/fpm_conf.c

@@ -98,6 +98,9 @@ static struct ini_value_parser_s ini_fpm_global_options[] = {
 	{ "process_control_timeout",     &fpm_conf_set_time,            GO(process_control_timeout) },
 	{ "process.max",                 &fpm_conf_set_integer,         GO(process_max) },
 	{ "process.priority",            &fpm_conf_set_integer,         GO(process_priority) },
+#if HAVE_FPM_CPUAFFINITY
+	{ "process.cpumask",             &fpm_conf_set_string,          GO(process_cpumask) },
+#endif
 	{ "daemonize",                   &fpm_conf_set_boolean,         GO(daemonize) },
 	{ "rlimit_files",                &fpm_conf_set_integer,         GO(rlimit_files) },
 	{ "rlimit_core",                 &fpm_conf_set_rlimit_core,     GO(rlimit_core) },
@@ -130,6 +133,9 @@ static struct ini_value_parser_s ini_fpm_pool_options[] = {
 #endif
 	{ "process.priority",          &fpm_conf_set_integer,     WPO(process_priority) },
 	{ "process.dumpable",          &fpm_conf_set_boolean,     WPO(process_dumpable) },
+#if HAVE_FPM_CPUAFFINITY
+	{ "process.cpumask",           &fpm_conf_set_string,      WPO(process_cpumask) },
+#endif
 	{ "pm",                        &fpm_conf_set_pm,          WPO(pm) },
 	{ "pm.max_children",           &fpm_conf_set_integer,     WPO(pm_max_children) },
 	{ "pm.start_servers",          &fpm_conf_set_integer,     WPO(pm_start_servers) },
@@ -621,6 +627,9 @@ static void *fpm_worker_pool_config_alloc(void)
 	wp->config->pm_process_idle_timeout = 10; /* 10s by default */
 	wp->config->process_priority = 64; /* 64 means unset */
 	wp->config->process_dumpable = 0;
+#if HAVE_FPM_CPUAFFINITY
+	wp->config->process_cpumask = NULL;
+#endif
 	wp->config->clear_env = 1;
 	wp->config->decorate_workers_output = 1;
 #ifdef SO_SETFIB

sapi/fpm/fpm/fpm_conf.h

@@ -44,6 +44,9 @@ struct fpm_global_config_s {
 	int systemd_watchdog;
 	int systemd_interval;
 #endif
+#if HAVE_FPM_CPUAFFINITY
+	char *process_cpumask;
+#endif
 };
 
 extern struct fpm_global_config_s fpm_global_config;
@@ -107,6 +110,9 @@ struct fpm_worker_pool_config_s {
 #ifdef SO_SETFIB
 	int listen_setfib;
 #endif
+#if HAVE_FPM_CPUAFFINITY
+	char *process_cpumask;
+#endif
 };
 
 struct ini_value_parser_s {

sapi/fpm/fpm/fpm_config.h

@@ -75,3 +75,16 @@
 #else
 # define HAVE_FPM_LQ 0
 #endif
+
+#if defined(HAVE_SCHED_SETAFFINITY)
+/*
+ * to expand to other platforms capable of this granularity (some BSD, solaris, ...).
+ * macOS is a specific case with an api working fine on intel architecture
+ * whereas on arm the api and semantic behind is different, since it is about
+ * Quality Of Service, i.e. binding to a group of cores for high performance
+ * vs cores for low energy consumption.
+ */
+# define HAVE_FPM_CPUAFFINITY 1
+#else
+# define HAVE_FPM_CPUAFFINITY 0
+#endif

sapi/fpm/fpm/fpm_unix.c

@@ -35,6 +35,10 @@
 #include <selinux/selinux.h>
 #endif
 
+#ifdef HAVE_SCHED_H
+#include <sched.h>
+#endif
+
 #include "fpm.h"
 #include "fpm_conf.h"
 #include "fpm_cleanup.h"
@@ -349,6 +353,62 @@ static int fpm_unix_conf_wp(struct fpm_worker_pool_s *wp) /* {{{ */
 }
 /* }}} */
 
+#if HAVE_FPM_CPUAFFINITY
+static long fpm_cpumax(void)
+{
+	static long cpuid = LONG_MIN;
+	if (cpuid == LONG_MIN) {
+		cpuid = sysconf(_SC_NPROCESSORS_ONLN);
+	}
+
+	return cpuid;
+}
+
+static int fpm_cpusrange(char *cpumask, int *min, int *max) {
+	char *cpumasksep;
+	long cpumax;
+	cpumax = fpm_cpumax();
+	if (0 >= cpumax) {
+		return -1;
+	}
+	*min = strtol(cpumask, &cpumasksep, 0);
+	if (errno || *min < 0 || *min >= cpumax) {
+		return -1;
+	}
+
+	*max = *min;
+	if (*cpumasksep == '-') {
+		if (strlen(cpumasksep) > 1) {
+			char *err;
+			*max = strtol(cpumasksep + 1, &err, 0);
+			if (errno || *err != '\0' || *max <= *min || *max >= cpumax) {
+				return -1;
+			}
+		} else {
+			return -1;
+		}
+	}
+	return 0;
+}
+
+static int fpm_setcpuaffinity(int min, int max)
+{
+#ifdef HAVE_SCHED_SETAFFINITY
+	cpu_set_t cset;
+	int i;
+
+	CPU_ZERO(&cset);
+	for (i = min; i <= max; i ++) {
+		if (!CPU_ISSET(i, &cset)) {
+			CPU_SET(i, &cset);
+		}
+	}
+
+	return sched_setaffinity(0, sizeof(cset), &cset);
+#endif
+}
+#endif
+
 int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 {
 	int is_root = !geteuid();
@@ -402,6 +462,20 @@ int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 			}
 		}
 
+#if HAVE_FPM_CPUAFFINITY
+		if (wp->config->process_cpumask) {
+			int fcpu, lcpu;
+
+			if (0 > fpm_cpusrange(wp->config->process_cpumask, &fcpu, &lcpu)) {
+				zlog(ZLOG_SYSERROR, "[pool %s] failed to fpm_cpusrange(%s)", wp->config->name, wp->config->process_cpumask);
+				return -1;
+			}
+			if (0 > fpm_setcpuaffinity(fcpu, lcpu)) {
+				zlog(ZLOG_SYSERROR, "[pool %s] failed to fpm_setcpuaffinity(%s)", wp->config->name, wp->config->process_cpumask);
+				return -1;
+			}
+		}
+#endif
 		if (wp->set_gid) {
 			if (0 > setgid(wp->set_gid)) {
 				zlog(ZLOG_SYSERROR, "[pool %s] failed to setgid(%d)", wp->config->name, wp->set_gid);
@@ -619,6 +693,25 @@ int fpm_unix_init_main(void)
 		}
 	}
 
+#if HAVE_FPM_CPUAFFINITY
+	if (fpm_global_config.process_cpumask) {
+		if (is_root) {
+			int fcpu, lcpu;
+
+			if (0 > fpm_cpusrange(fpm_global_config.process_cpumask, &fcpu, &lcpu)) {
+				zlog(ZLOG_SYSERROR, "failed to fpm_cpurange(%s)", fpm_global_config.process_cpumask);
+				return -1;
+			}
+			if (0 > fpm_setcpuaffinity(fcpu, lcpu)) {
+				zlog(ZLOG_SYSERROR, "failed to fpm_setcpuaffinity(%s)", fpm_global_config.process_cpumask);
+				return -1;
+			}
+		} else {
+			zlog(ZLOG_NOTICE, "'process.cpumask' directive is ignored when FPM is not running as root");
+		}
+	}
+#endif
+
 	fpm_globals.parent_pid = getpid();
 	for (wp = fpm_worker_all_pools; wp; wp = wp->next) {
 		if (0 > fpm_unix_conf_wp(wp)) {

sapi/fpm/php-fpm.conf.in

@@ -125,6 +125,12 @@
 ; Default value: 10
 ;systemd_interval = 10
 
+; Bind the master process to a cpu set.
+; The value can be one cpu id or a range.
+;
+; Default Value: not set
+; process.cpumask = 0-3
+
 ;;;;;;;;;;;;;;;;;;;;
 ; Pool Definitions ;
 ;;;;;;;;;;;;;;;;;;;;