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".

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 \
@@ -570,6 +572,7 @@ AC_CHECK_FUNCS(
 alphasort \
 asctime_r \
 chroot \
+cpuset_setaffinity \
 ctime_r \
 explicit_memset \
 fdatasync \
@@ -607,6 +610,7 @@ poll \
 pthread_jit_write_protect_np \
 putenv \
 scandir \
+sched_setaffinity \
 setitimer \
 setenv \
 shutdown \

sapi/fpm/fpm/fpm_conf.c

@@ -99,6 +99,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) },
@@ -131,6 +134,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) },
@@ -622,6 +628,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"
@@ -392,6 +401,103 @@ static int fpm_unix_conf_wp(struct fpm_worker_pool_s *wp) /* {{{ */
 }
 /* }}} */
 
+#if HAVE_FPM_CPUAFFINITY
+struct fpm_cpuaffinity_conf {
+#if defined(HAVE_SCHED_SETAFFINITY) || defined(HAVE_CPUSET_SETAFFINITY)
+	cpu_set_t cset;
+#endif
+	long min;
+	long max;
+};
+
+static long fpm_cpumax(void)
+{
+	static long cpuid = LONG_MIN;
+	if (cpuid == LONG_MIN) {
+		cpuid = sysconf(_SC_NPROCESSORS_ONLN);
+	}
+
+	return cpuid;
+}
+
+static void fpm_cpuaffinity_init(struct fpm_cpuaffinity_conf *c)
+{
+#if defined(HAVE_SCHED_SETAFFINITY) || defined(HAVE_CPUSET_SETAFFINITY)
+	CPU_ZERO(&c->cset);
+#endif
+}
+
+static void fpm_cpuaffinity_add(struct fpm_cpuaffinity_conf *c)
+{
+#if defined(HAVE_SCHED_SETAFFINITY) || defined(HAVE_CPUSET_SETAFFINITY)
+	int i;
+
+	for (i = c->min; i <= c->max; i ++) {
+		if (!CPU_ISSET(i, &c->cset)) {
+			CPU_SET(i, &c->cset);
+		}
+	}
+#endif
+}
+
+static int fpm_cpuaffinity_set(struct fpm_cpuaffinity_conf *c)
+{
+#if defined(HAVE_SCHED_SETAFFINITY)
+	return sched_setaffinity(0, sizeof(c->cset), &c->cset);
+#elif defined(HAVE_CPUSET_SETAFFINITY)
+	return cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(c->cset), &c->cset);
+#endif
+}
+
+static void fpm_cpuaffinity_destroy(struct fpm_cpuaffinity_conf *c)
+{
+	// some platform/apis requires to allocates data on the heap
+}
+
+static int fpm_setcpuaffinity(char *cpumask)
+{
+	char *token, *buf;
+	struct fpm_cpuaffinity_conf fconf;
+	int r, cpumax;
+
+	r = -1;
+	cpumax = fpm_cpumax();
+
+	fpm_cpuaffinity_init(&fconf);
+	token = php_strtok_r(cpumask, ";", &buf);
+
+	while (token) {
+		char *cpumasksep;
+
+		fconf.min = strtol(token, &cpumasksep, 0);
+		if (errno || fconf.min > cpumax) {
+			goto fail;
+		}
+		fconf.max = fconf.min;
+		if (*cpumasksep == '-') {
+			if (strlen(cpumasksep) > 1) {
+				char *err;
+				fconf.max = strtol(cpumasksep + 1, &err, 0);
+				if (errno || *err != '\0' || fconf.max < fconf.min || fconf.max > cpumax) {
+					return -1;
+				}
+			} else {
+				return -1;
+			}
+		}
+
+		fpm_cpuaffinity_add(&fconf);
+
+		token = php_strtok_r(NULL, ";", &buf);
+	}
+
+fail:
+	r = fpm_cpuaffinity_set(&fconf);
+	fpm_cpuaffinity_destroy(&fconf);
+	return r;
+}
+#endif
+
 int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 {
 	int is_root = !geteuid();
@@ -416,6 +522,15 @@ 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 (wp->config->process_cpumask) {
+
+		if (0 > fpm_setcpuaffinity(wp->config->process_cpumask)) {
+			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)) {
@@ -662,6 +777,15 @@ int fpm_unix_init_main(void)
 		}
 	}
 
+#if HAVE_FPM_CPUAFFINITY
+	if (fpm_global_config.process_cpumask) {
+		if (0 > fpm_setcpuaffinity(fpm_global_config.process_cpumask)) {
+			zlog(ZLOG_SYSERROR, "failed to fpm_setcpuaffinity(%s)", fpm_global_config.process_cpumask);
+			return -1;
+		}
+	}
+#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,14 @@
 ; 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 = "4"
+; process.cpumask = "0-3"
+; process.cpumask = "1-4;8-16;32-48"
+
 ;;;;;;;;;;;;;;;;;;;;
 ; Pool Definitions ;
 ;;;;;;;;;;;;;;;;;;;;

sapi/fpm/tests/cpuaffinity-fail.phpt

@@ -0,0 +1,43 @@
+--TEST--
+FPM: cpu affinity test
+--SKIPIF--
+<?php include "skipif.inc";
+
+if (!str_contains(PHP_OS, 'Linux')) {
+    die('skipped supported only on Linux');
+}
+?>
+--FILE--
+<?php
+
+require_once "tester.inc";
+
+$cfg = <<<EOT
+[global]
+process.cpumask = 1000024
+error_log = {{FILE:LOG}}
+pid = {{FILE:PID}}
+[unconfined]
+listen = {{ADDR:IPv4}}
+pm = dynamic
+pm.max_children = 1
+pm.start_servers = 1
+pm.min_spare_servers = 1
+pm.max_spare_servers = 1
+EOT;
+
+$tester = new FPM\Tester($cfg);
+$tester->start();
+$tester->expectLogError("failed to fpm_setcpuaffinity\(\d+\): Invalid argument \(\d+\)");
+$tester->expectLogError("FPM initialization failed");
+$tester->close();
+
+?>
+Done
+--EXPECT--
+Done
+--CLEAN--
+<?php
+require_once "tester.inc";
+FPM\Tester::clean();
+?>

sapi/fpm/tests/cpuaffinity.phpt

@@ -0,0 +1,44 @@
+--TEST--
+FPM: cpu affinity test
+--SKIPIF--
+<?php include "skipif.inc";
+
+if (!str_contains(PHP_OS, 'Linux')) {
+    die('skipped supported only on Linux');
+}
+?>
+--FILE--
+<?php
+
+require_once "tester.inc";
+
+$cfg = <<<EOT
+[global]
+error_log = {{FILE:LOG}}
+pid = {{FILE:PID}}
+[unconfined]
+listen = {{ADDR:IPv4}}
+pm = dynamic
+pm.max_children = 1
+pm.start_servers = 1
+pm.min_spare_servers = 1
+pm.max_spare_servers = 1
+process.cpumask = 1
+EOT;
+
+$tester = new FPM\Tester($cfg);
+$tester->start();
+$tester->expectLogStartNotices();
+$tester->terminate();
+$tester->expectLogTerminatingNotices();
+$tester->close();
+
+?>
+Done
+--EXPECT--
+Done
+--CLEAN--
+<?php
+require_once "tester.inc";
+FPM\Tester::clean();
+?>

sapi/fpm/www.conf.in

@@ -80,6 +80,14 @@ 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 = "8"
+; process.cpumask = "0-3"
+; process.cpumask = "4-7;10-12"
+
 ; 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