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 the 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,8 +403,10 @@ pty.h \
 pwd.h \
 resolv.h \
 strings.h \
+sched.h \
 syslog.h \
 sysexits.h \
+sys/cpuset.h \
 sys/ioctl.h \
 sys/file.h \
 sys/mman.h \
@@ -568,6 +570,7 @@ AC_CHECK_FUNCS(
 alphasort \
 asctime_r \
 chroot \
+cpuset_setaffinity \
 ctime_r \
 explicit_memset \
 fdatasync \
@@ -605,6 +608,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) || defined(HAVE_CPUSET_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,15 @@
 #include <selinux/selinux.h>
 #endif
 
+#ifdef HAVE_SCHED_H
+#include <sched.h>
+#endif
+
+#ifdef HAVE_SYS_CPUSET_H
+#include <sys/cpuset.h>
+typedef cpuset_t cpu_set_t;
+#endif
+
 #include "fpm.h"
 #include "fpm_conf.h"
 #include "fpm_cleanup.h"
@@ -349,6 +358,66 @@ 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)
+{
+#if defined(HAVE_SCHED_SETAFFINITY) || defined(HAVE_CPUSET_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);
+		}
+	}
+
+#if defined(HAVE_SCHED_SETAFFINITY)
+	return sched_setaffinity(0, sizeof(cset), &cset);
+#else
+	return cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(cset), &cset);
+#endif
+#endif
+}
+#endif
+
 int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 {
 	int is_root = !geteuid();
@@ -373,6 +442,20 @@ int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 			zlog(ZLOG_SYSERROR, "[pool %s] failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", wp->config->name, wp->config->rlimit_core);
 		}
 	}
+#if HAVE_FPM_CPUAFFINITY
+	if (is_root && 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 (is_root && wp->config->chroot && *wp->config->chroot) {
 		if (0 > chroot(wp->config->chroot)) {
@@ -619,6 +702,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_cpusrange(%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 ;
 ;;;;;;;;;;;;;;;;;;;;

sapi/fpm/www.conf.in

@@ -74,6 +74,12 @@ listen = 127.0.0.1:9000
 ; Default Value: no set
 ; process.priority = -19
 
+; Bind the pool processes to a cpu set.
+; The value can be one cpu id or a range.
+;
+; Default Value: inherits master's cpu affinity
+; process.cpumask = 4-7
+
 ; Set the process dumpable flag (PR_SET_DUMPABLE prctl for Linux or
 ; PROC_TRACE_CTL procctl for FreeBSD) even if the process user
 ; or group is different than the master process user. It allows to create process