How many processors does Windows 10 support? It’s a simple question, but the correct answer is surprisingly hard to come by.
What led me to ask this question was curiosity: I wondered whether it would be possible to run Windows 10 on a Supermicro 7089P-TR4T – a single-node server with eight Intel Xeon Scalable sockets in an S8S configuration.
Windows Server licenses come with a baseline limit of 16 physical processor cores. If you want to use more cores, you have to buy additional core licenses. For example, on an 8-socket system filled with Xeon 8280 CPUs, you’ve got 8 * 28 = 224 physical cores, which would require the purchase of thirteen additional 16-core licenses. There’s one exception here: each CPU socket must be licensed for at least 8 cores. This restriction means that you couldn’t, for example, run four quad-core CPUs on a base license – you’d need an additional 16-core license for that, to make up 8 licensed cores per socket. It’s also worth noting that only physical cores count; SMT cores (or “threads”) are not included in the licensing. Those additional licenses aren’t cheap. At the time of writing a Windows Server 2019 Datacenter Additional 16 Core licenses cost more than 4000 GBP.
Windows Desktop is much less restrictive. Each edition of Windows 10 has an associated maximum number of allowed CPU sockets:
- Windows 10 Home supports 1 socket
- Windows 10 Pro and Windows 10 Education support 2 sockets
- Windows 10 Pro for Workstations supports 4 sockets
(quick terminology aside: a specific version and edition of Windows is usually referred to as an SKU, and it is common to refer to groups of related versions/editions of Windows as a set of SKUs, e.g. “Windows Desktop SKUs” means any desktop edition of Windows)
But where do these numbers come from? I could not find any official Microsoft documentation that details these limits.
At the time of writing, the Wikipedia article for Windows 10 editions lists the above socket count limits, plus core count limits, for each Windows 10 edition:
| Feature | Home | Pro | Education | Pro for Workstations | Enterprise |
| Maximum CPU sockets | 1 | 2 | 2 | 4 | 2 |
| Maximum CPU cores | 64 | 128 | 128 | 256 | 256 |
So, according to these numbers, we could run Windows 10 on a four-socket server, but we can’t run it on an eight-socket server. Of course “unsupported” just means “a challenge”, so I started looking into how I could get around the limit.
The first thing I did was throw the ntoskrnl.exe binary from my Windows 10 Pro for Workstations install into Ghidra and started looking for query/helper functions that determine the number of CPUs or CPU sockets on the system. My plan was to find out how the kernel keeps track of this count, look for associated code that initializes the count during boot, and use that to find where the socket count limitation is applied. After a bunch of digging and some help from prior work by other reverse engineers, I got a good grasp of how this all works.
Just to get everyone on the same footing, it helps to understand some terminology around cores and processors:
- A physical CPU, package, or socket refers to a whole physical CPU, i.e. a physical device that you can touch.
- A physical core or physical processor refers to an actual physical core inside a CPU, not an SMT core/thread.
- A logical core, logical processor, or processor thread refers to any logical processor on which code can be executed, including SMT threads.
- A NUMA node is a concept in non-uniform memory access (NUMA) topology referring to a set of logical processors that share the same memory controller. You usually have one NUMA node per CPU socket, but some AMD CPUs have multiple NUMA nodes per socket. Memory accesses across NUMA nodes require coordination between nodes, leading to increased latency.
With that all out of the way, let’s dig in.
So what does all of this mean? I’m pretty certain that it means per-edition core count limits simply don’t exist in Windows 10, and probably didn’t in previous versions either. Most likely, Windows 7 supported a maximum of 4 groups of 64 logical processors, whereas Windows 8 and later support a maximum of 20 groups of 64 logical processors.
To wrap it all up, here are the actual limits:
- Sockets:
- 1 socket on Windows 10 Home (due to ProductPolicy)
- 2 sockets on Windows 10 Pro / Education (due to ProductPolicy)
- 4 sockets on Windows 10 Pro for Workstations / Enterprise (due to ProductPolicy)
- 64 sockets on Windows Server 2016, 2019, and 2022 (due to ProductPolicy), although this is effectively capped at 20 due to the processor group limit.
- Physical Cores:
- Physical cores must be licensed on Windows Server SKUs, with a minimum of 8 cores licensed per socket, but there is no upper limit on the number of supported cores.
- There is no specific maximum physical core count on Windows 10.
- Logical Processors:
- Processor groups are unsupported on Vista and prior, meaning a hard limit of 32 logical processors on 32-bit and 64 logical processors on 64-bit is set by the affinity mask.
- 32-bit builds of Windows 7 and later are limited to 32 logical processors.
- 4 processor groups are supported on Windows 7 (NT 6.1) on 64-bit builds. Each group can contain up to 64 logical processors. Each group must be associated with a single NUMA node.
- 20 processor groups are supported on Windows 8 (NT 6.2) and later, on 64-bit builds. This leads to a theoretical limit of 1280 logical processors. Each processor group must be associated with a single NUMA node, and the kernel will create fake NUMA nodes if a single socket has more than 64 logical processors.
- As of build 20348, groups no longer require a 1:1 mapping with NUMA nodes, so fake NUMA nodes are no longer created when a socket has more than 64 logical processors. One group cannot span multiple NUMA nodes, but each NUMA node can have multiple processor groups assigned to it. This has no affect on the maximum counts.
I am unaware of any commercially available x86_64 system, at time of writing, that can get close to the 1280 logical processor limit. An S8S board with Xeon 8280 processors gets as high as 448 logical processors. Higher core count Xeon Scalable Gen2 processors are available (9 series) but they are not for general sale and only support 2S configurations. Xeon Scalable Gen3 processors are documented as only supporting 2S scaling, even on the Xeon 8380. AMD EPYC offers higher core counts per socket, but so far we haven’t seen Infinity Fabric scaling beyond 2S. One can approximate the limit using CPU overcommitting in a hypervisor (KVM supports this), which basically involves lying about how many processors you have, but that’s cheating. It’s possible that specialised hypervisors operating on top of compute clusters can host a virtual machine with 1280 logical processors actually backed by hardware, but those processors would be on physically separate compute nodes interconnected by RDMA networking, and you don’t tend to run vanilla Windows 10 installs on that kind of platform.
https://codeinsecurity.wordpress.com/2022/04/07/cpu-socket-and-core-count-limits-in-windows-10-and-how-to-remove-them/
