From the article:

Here is an interesting one. Intel has a 66-thread-per-core processor with 8 cores in a socket (528 threads?) The cache apparently is not well used due to the workload. This is a RISC ISA not x86.

I guess it is like a GPU where you have so many threads that it hides pretty much all the memory latency?

shades of https://en.wikipedia.org/wiki/Cray_MTA

50 shades of Cray

66 per core does seem a bit odd! maybe 2 are for routing/metadata or something.

"8-core processor with 66 threads per core." 66*8 = 528. Why 66 is not explained.

Maybe they just couldn't fit 67?

Maybe 2 higher-powered primary threads + 64 aux threads or something. I don't know how that makes sense as part of a single core but I don't have a better guess.

That's what it is, as shown on slide 6 (Die Architecture). Personally I would call this 16 big cores and 32 throughput cores but for some reason Intel is calling it 8 cores.

Yes it is. They have four 16 thread pipelines, and two single thread pipelines per core. 4*16=64 and 64+2=66

So, why do they consider that 1 core? Isn't that more like a "compute complex" of multiple cores, as seen on zen 2, but with different core architectures attached instead of 4 cores of the same design?

I'd be inclined to call them multiple cores myself, but if they all share the same pipe to main memory that would be a plausible reason to call them all the same core.

Look at slide 6, "Die Architecture" (https://www.servethehome.com/wp-content/uploads/2023/08/Inte...).

The diagram shows 8 gray boxes (in 2 columns of 4). Each gray box is a core.

Above that is a detailed view of what each core looks like. There's a middle section labeled "Crossbar", and above that are 3 boxes labeled STP, MTP, and MTP. Below that are another 3 identical boxes. So each core has 4x MTPs and 2x STP.

What are those? The text of the same slide says MTP is "Multi-Threaded Pipelines" with "16 threads per pipeline" and STP is "Single-Threaded Pipelines" with (self-evidently) 1 thread per pipeline.

And 4 * 16 + 2 * 1 = 66, so 66 threads per core.

Good one. These presentations are like 30 min each so it is hard to stay on top of all of them.

66 = 64 slow GPU-like threads + 2 very fast CPU-like threads

It's simple: 528 = 8 * (2 +64),

where 2 is number of slow threads, like current CPU,

and 64 are more like GPU threads.

This architecture could be next step in GPU integration. Hope they manage to write efficient implementation for standard math libs. It could be faster than separate CPU+GPU in one package.

I think it’s 2 fast threads that anre like normal cpu core threads (ooo, etc) and 64 simpler threads that are expected to be mostly waiting on ram.