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

sapi/fpm/config.m4

@@ -7,7 +7,8 @@ PHP_ARG_ENABLE([fpm],,
 dnl Configure checks.
 AC_DEFUN([AC_FPM_STDLIBS],
 [
-  AC_CHECK_FUNCS(clearenv setproctitle setproctitle_fast)
+  AC_CHECK_FUNCS(clearenv setproctitle setproctitle_fast cpuset_setaffinity sched_setaffinity)
+  AC_CHECK_HEADERS([sys/cpuset.h sched.h])
 
   AC_SEARCH_LIBS(socket, socket)
   AC_SEARCH_LIBS(inet_addr, nsl)

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.cpu_list",            &fpm_conf_set_string,          GO(process_cpu_list) },
+#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.cpu_list",          &fpm_conf_set_string,      WPO(process_cpu_list) },
+#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_cpu_list = NULL;
+#endif
 	wp->config->clear_env = 1;
 	wp->config->decorate_workers_output = 1;
 #ifdef SO_SETFIB
@@ -1733,6 +1742,9 @@ static void fpm_conf_dump(void)
 	} else {
 		zlog(ZLOG_NOTICE, "\tprocess.priority = %d", fpm_global_config.process_priority);
 	}
+#if HAVE_FPM_CPUAFFINITY
+	zlog(ZLOG_NOTICE, "\tprocess.cpu_list = %s",            STR2STR(fpm_global_config.process_cpu_list));
+#endif
 	zlog(ZLOG_NOTICE, "\tdaemonize = %s",                   BOOL2STR(fpm_global_config.daemonize));
 	zlog(ZLOG_NOTICE, "\trlimit_files = %d",                fpm_global_config.rlimit_files);
 	zlog(ZLOG_NOTICE, "\trlimit_core = %d",                 fpm_global_config.rlimit_core);
@@ -1772,6 +1784,9 @@ static void fpm_conf_dump(void)
 			zlog(ZLOG_NOTICE, "\tprocess.priority = %d", wp->config->process_priority);
 		}
 		zlog(ZLOG_NOTICE, "\tprocess.dumpable = %s",           BOOL2STR(wp->config->process_dumpable));
+#if HAVE_FPM_CPUAFFINITY
+		zlog(ZLOG_NOTICE, "\tprocess.cpu_list = %s",           STR2STR(wp->config->process_cpu_list));
+#endif
 		zlog(ZLOG_NOTICE, "\tpm = %s",                         PM2STR(wp->config->pm));
 		zlog(ZLOG_NOTICE, "\tpm.max_children = %d",            wp->config->pm_max_children);
 		zlog(ZLOG_NOTICE, "\tpm.start_servers = %d",           wp->config->pm_start_servers);

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_cpu_list;
+#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_cpu_list;
+#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

@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/types.h>
+#include <errno.h>
 #include <pwd.h>
 #include <grp.h>
 
@@ -35,6 +36,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 +402,101 @@ static int fpm_unix_conf_wp(struct fpm_worker_pool_s *wp) /* {{{ */
 }
 /* }}} */
 
+#if HAVE_FPM_CPUAFFINITY
+struct fpm_cpuaffinity_conf {
+	cpu_set_t cset;
+	long min;
+	long max;
+};
+
+static long fpm_cpumax(void)
+{
+	static long cpuid = LONG_MIN;
+	if (cpuid == LONG_MIN) {
+		cpu_set_t cset;
+#if defined(HAVE_SCHED_SETAFFINITY)
+		if (sched_getaffinity(0, sizeof(cset), &cset) == 0) {
+#elif defined(HAVE_CPUSET_SETAFFINITY)
+		if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(cset), &cset) == 0) {
+#endif
+			cpuid = CPU_COUNT(&cset);
+		} else {
+			cpuid = -1;
+		}
+	}
+
+	return cpuid;
+}
+
+static void fpm_cpuaffinity_init(struct fpm_cpuaffinity_conf *c)
+{
+	CPU_ZERO(&c->cset);
+}
+
+static void fpm_cpuaffinity_add(struct fpm_cpuaffinity_conf *c)
+{
+#if defined(HAVE_FPM_CPUAFFINITY)
+	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 int fpm_setcpuaffinity(char *cpu_list)
+{
+	char *token, *buf;
+	struct fpm_cpuaffinity_conf fconf;
+	int r, cpumax;
+
+	r = -1;
+	cpumax = fpm_cpumax();
+
+	fpm_cpuaffinity_init(&fconf);
+	token = php_strtok_r(cpu_list, ",", &buf);
+
+	while (token) {
+		char *cpu_listsep;
+
+		fconf.min = strtol(token, &cpu_listsep, 0);
+		if (errno || fconf.min < 0 || fconf.min > cpumax) {
+			return -1;
+		}
+		fconf.max = fconf.min;
+		if (*cpu_listsep == '-') {
+			if (strlen(cpu_listsep) > 1) {
+				char *err;
+				fconf.max = strtol(cpu_listsep + 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);
+	}
+
+	r = fpm_cpuaffinity_set(&fconf);
+	return r;
+}
+#endif
+
 int fpm_unix_init_child(struct fpm_worker_pool_s *wp) /* {{{ */
 {
 	int is_root = !geteuid();
@@ -416,6 +521,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_cpu_list) {
+
+		if (0 > fpm_setcpuaffinity(wp->config->process_cpu_list)) {
+			zlog(ZLOG_SYSERROR, "[pool %s] failed to fpm_setcpuaffinity(%s)", wp->config->name, wp->config->process_cpu_list);
+			return -1;
+		}
+	}
+#endif
 
 	if (is_root && wp->config->chroot && *wp->config->chroot) {
 		if (0 > chroot(wp->config->chroot)) {
@@ -662,6 +776,15 @@ int fpm_unix_init_main(void)
 		}
 	}
 
+#if HAVE_FPM_CPUAFFINITY
+	if (fpm_global_config.process_cpu_list) {
+		if (0 > fpm_setcpuaffinity(fpm_global_config.process_cpu_list)) {
+			zlog(ZLOG_SYSERROR, "failed to fpm_setcpuaffinity(%s)", fpm_global_config.process_cpu_list);
+			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,18 @@
 ; Default value: 10
 ;systemd_interval = 10
 
+; Bind the master process to a cpu set.
+; The value can be one cpu id, a range or a list thereof.
+;
+; Default Value: not set
+; Valid syntaxes are:
+;       process.cpu_list = "cpu id"                 - to bind to a single core
+;       process.cpu_list = "min cpu id-max cpu id"  - to bind to a core range
+                                                      from minimum cpu id to max
+;       process.cpu_list = "[min cpu id-max cpu id],[min cpu id-max cpu id],..."
+                                                    - to bind to multiple ranges
+                                                      separated by a comma
+
 ;;;;;;;;;;;;;;;;;;;;
 ; 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') && !str_contains(PHP_OS, 'FreeBSD')) {
+    die('skipped supported only on Linux and FreeBSD');
+}
+?>
+--FILE--
+<?php
+
+require_once "tester.inc";
+
+$cfg = <<<EOT
+[global]
+process.cpu_list = 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+\): Inappropriate ioctl for device \(\d+\)");
+$tester->expectLogError("FPM initialization failed");
+$tester->close();
+
+?>
+Done
+--EXPECT--
+Done
+--CLEAN--
+<?php
+require_once "tester.inc";
+FPM\Tester::clean();
+?>

sapi/fpm/tests/cpuaffinity-range.phpt

@@ -0,0 +1,55 @@
+--TEST--
+FPM: cpu affinity test, range
+--SKIPIF--
+<?php include "skipif.inc";
+
+if (!str_contains(PHP_OS, 'Linux') && !str_contains(PHP_OS, 'FreeBSD')) {
+    die('skipped supported only on Linux and FreeBSD');
+}
+
+if (str_contains(PHP_OS, 'Linux')) {
+    $cmd = 'nproc';
+} else {
+    $cmd = 'sysctl hw.ncpus';
+}
+
+$nproc = intval(exec($cmd));
+if ($nproc < 4) {
+    die('skipped supported only on 4 cores or more environments');
+}
+?>
+--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.cpu_list = 0-1,2-3
+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();
+?>