[Breaking change] `Environment.ProcessorCount` on Windows takes processor affinity into account

[kouvel]

When the process is affinitized on startup, the behavior of Environment.ProcessorCount currently differs between Windows and Linux. On Linux, the property returns the number of processors available according to the affinity mask. On Windows, the property returns the number of processors configured in the system and ignores the affinity mask. The property is often used to determine the amount of parallelism to use in the process, and it has been observed that not limiting the property's value based on affinitization can lead to worse performance.

On Linux, CPU resource limits placed through cgroups also affect the value returned by the property, as we have found through trial-and-error that returning the restricted number of processors from this property is the most appropriate behavior that makes most callers work well.

Goal

• Have Environment.ProcessorCount return a value that represents an appropriate level of parallelism that may be used in the process based on affinitization and CPU resource limits
• Have the property return a consistent value in comparable relevant configuration between Windows and Linux

Behavior before change

On a machine with 8 logical processors:

• When the process is affinitized to 1 logical processor:
  • Windows: Environment.ProcessorCount == 8
  • Linux: Environment.ProcessorCount == 1
• When CPU resources for the process are limited to the equivalent of 1 logical processor:
  • Windows: Environment.ProcessorCount == 8
  • Linux: Environment.ProcessorCount == 1

Behavior after #45943

• When the process is affinitized to 1 logical processor:
  • Windows: Environment.ProcessorCount == 1
  • Linux: Environment.ProcessorCount == 1
• When CPU resources for the process are limited to the equivalent of 1 logical processor:
  • Windows: Environment.ProcessorCount == 8
  • Linux: Environment.ProcessorCount == 1

Behavior after other such issues are fixed (no PR yet)

• When the process is affinitized to 1 logical processor:
  • Windows: Environment.ProcessorCount == 1
  • Linux: Environment.ProcessorCount == 1
• When CPU resources for the process are limited to the equivalent of 1 logical processor:
  • Windows: Environment.ProcessorCount == 1
  • Linux: Environment.ProcessorCount == 1

Versions affected

.NET 6

Potential breaks on Windows and workarounds

• Code that uses Environment.ProcessorCount and scales down parallelism based on other app or system configuration (including potentially the process' affinity mask) may end up using lower parallelism than intended
  • Workaround may be to update the application's parallelism scaling
• Code that expects Environment.ProcessorCount to return the configured logical processor count may have unexpected results. For example code that verifies that the process is not started affinitized by comparing the affinitized processor count to Environment.ProcessorCount would fail to detect affinitized startup because the comparison would be equal. Or the process may intend to display the total processor count.
  • Workaround may be to pinvoke to get the total processor count. May not be ideal. Providing full information in other APIs would need discussion to determine what to provide, for example, number of processors configured in the system, number of processors that are online/offline, number of processors the process is affinitized to, CPU quota limits, etc.
• Code that happens to perform worse when the value returned by Environment.ProcessorCount is limited by affinitization or CPU resource limits
  • If these become common, it may be necessary to provide a workaround, such as to provide a way to configure what Environment.ProcessorCount would return, or to provide other APIs

Currently, a config option is not provided to revert the behavior. The difference in behavior between Windows and Linux existed in .NET 5 and below, where Linux has not offered a config option to provide the total processor count, so there hasn't been a workaround for the above issues on Linux so far.

Non-breaking

• The thread pool already took affinitization into account in the default parallelization it uses on Windows, when the process is not configured to use multiple CPU groups (the default). In .NET 6 thread pool worker thread management was migrated to managed code and uses Environment.ProcessorCount, so after Update Environment.ProcessorCount on Windows to take into account the processor affinity mask #45943 thread pool worker thread parallelization in .NET 6 would be the same as before in that scenario.

[kouvel]

CC @dotnet/compat

[CoffeeFlux]

Do you know if we need to fix this on the Mono side as well?

[kouvel]

It looks like Mono already uses sched_getaffinity, and notes some other interesting points:

runtime/src/mono/mono/utils/mono-proclib.c

Lines 754 to 864 in 9f8aab7

	/**
	* mono_cpu_count:
	* \returns the number of processors on the system.
	*/
	#ifndef HOST_WIN32
	int
	mono_cpu_count (void)
	{
	#ifdef HOST_ANDROID
	/* Android tries really hard to save power by powering off CPUs on SMP phones which
	* means the normal way to query cpu count returns a wrong value with userspace API.
	* Instead we use /sys entries to query the actual hardware CPU count.
	*/
	int count = 0;
	char buffer[8] = {'\0'};
	int present = open ("/sys/devices/system/cpu/present", O_RDONLY);
	/* Format of the /sys entry is a cpulist of indexes which in the case
	* of present is always of the form "0-(n-1)" when there is more than
	* 1 core, n being the number of CPU cores in the system. Otherwise
	* the value is simply 0
	*/
	if (present != -1 && read (present, (char*)buffer, sizeof (buffer)) > 3)
	count = strtol (((char*)buffer) + 2, NULL, 10);
	if (present != -1)
	close (present);
	if (count > 0)
	return count + 1;
	#endif
	#if defined(HOST_ARM) || defined (HOST_ARM64)
	/*
	* Recap from Alexander Köplinger <alex.koeplinger@outlook.com>:
	*
	* When we merged the change from PR #2722, we started seeing random failures on ARM in
	* the MonoTests.System.Threading.ThreadPoolTests.SetAndGetMaxThreads and
	* MonoTests.System.Threading.ManualResetEventSlimTests.Constructor_Defaults tests. Both
	* of those tests are dealing with Environment.ProcessorCount to verify some implementation
	* details.
	*
	* It turns out that on the Jetson TK1 board we use on public Jenkins and on ARM kernels
	* in general, the value returned by sched_getaffinity (or _SC_NPROCESSORS_ONLN) doesn't
	* contain CPUs/cores that are powered off for power saving reasons. This is contrary to
	* what happens on x86, where even cores in deep-sleep state are returned [1], [2]. This
	* means that we would get a processor count of 1 at one point in time and a higher value
	* when load increases later on as the system wakes CPUs.
	*
	* Various runtime pieces like the threadpool and also user code however relies on the
	* value returned by Environment.ProcessorCount e.g. for deciding how many parallel tasks
	* to start, thereby limiting the performance when that code thinks we only have one CPU.
	*
	* Talking to a few people, this was the reason why we changed to _SC_NPROCESSORS_CONF in
	* mono#1688 and why we added a special case for Android in mono@de3addc to get the "real"
	* number of processors in the system.
	*
	* Because of those issues Android/Dalvik also switched from _ONLN to _SC_NPROCESSORS_CONF
	* for the Java API Runtime.availableProcessors() too [3], citing:
	* > Traditionally this returned the number currently online, but many mobile devices are
	* able to take unused cores offline to save power, so releases newer than Android 4.2 (Jelly
	* Bean) return the maximum number of cores that could be made available if there were no
	* power or heat constraints.
	*
	* The problem with sticking to _SC_NPROCESSORS_CONF however is that it breaks down in
	* constrained environments like Docker or with an explicit CPU affinity set by the Linux
	* `taskset` command, They'd get a higher CPU count than can be used, start more threads etc.
	* which results in unnecessary context switches and overloaded systems. That's why we need
	* to respect sched_getaffinity.
	*
	* So while in an ideal world we would be able to rely on sched_getaffinity/_SC_NPROCESSORS_ONLN
	* to return the number of theoretically available CPUs regardless of power saving measures
	* everywhere, we can't do this on ARM.
	*
	* I think the pragmatic solution is the following:
	* * use sched_getaffinity (+ fallback to _SC_NPROCESSORS_ONLN in case of error) on x86. This
	* ensures we're inline with what OpenJDK [4] and CoreCLR [5] do
	* * use _SC_NPROCESSORS_CONF exclusively on ARM (I think we could eventually even get rid of
	* the HOST_ANDROID special case)
	*
	* Helpful links:
	*
	* [1] https://sourceware.org/ml/libc-alpha/2013-07/msg00383.html
	* [2] https://lists.01.org/pipermail/powertop/2012-September/000433.html
	* [3] https://android.googlesource.com/platform/libcore/+/750dc634e56c58d1d04f6a138734ac2b772900b5%5E1..750dc634e56c58d1d04f6a138734ac2b772900b5/
	* [4] https://bugs.openjdk.java.net/browse/JDK-6515172
	* [5] https://github.com/dotnet/coreclr/blob/7058273693db2555f127ce16e6b0c5b40fb04867/src/pal/src/misc/sysinfo.cpp#L148
	*/
	#if defined (_SC_NPROCESSORS_CONF) && defined (HAVE_SYSCONF)
	{
	int count = sysconf (_SC_NPROCESSORS_CONF);
	if (count > 0)
	return count;
	}
	#endif
	#else
	#ifdef HAVE_SCHED_GETAFFINITY
	{
	cpu_set_t set;
	if (sched_getaffinity (mono_process_current_pid (), sizeof (set), &set) == 0)
	return CPU_COUNT (&set);
	}
	#endif
	#if defined (_SC_NPROCESSORS_ONLN) && defined (HAVE_SYSCONF)
	{
	int count = sysconf (_SC_NPROCESSORS_ONLN);
	if (count > 0)
	return count;
	}
	#endif

[richlander]

This change seems intuitive to me and aligns with past feedback we've been given.

I wonder if we should add an Environment.MachineProcessorCount or something similar this release that always reported the max machine value. We've talked about it. Doing this would only make sense to me if we used that property from at least one place in the product

[kouvel]

Doc issue: dotnet/docs#24246