[systemvoltage]

Per core performance is the most interesting metric.

Edit: for relative comparison between CPUs, per core metric is the most interesting unless you also account for heat, price and many other factors. Comparing a 56-core CPU with 10-core M1 is a meaningless comparison.

[PaulDavisThe1st]

Not when building large software projects.

[ur-whale]

> Not when building large software projects.

Or run heavy renders of complex ray-traced scenes.

Or do heavy 3D reconstruction from 2D images.

Or run Monte-Carlo simulations to compute complex likelihoods on parametric trading models.

Or train ML models.

The list of things you can do with a computer with many, many cores is long, and some of these (or parts thereof) are sometimes rather annoying to map to a GPU.

[Someone]

It seems Apple thinks it _can_ map the essential ones to the GPU, though. If they didn’t, there would be more CPUs and less powerful other hardware.

‘Rather annoying’ certainly doesn’t have to be a problem. Apple can afford to pay engineers lots of money to write libraries that do that for you.

The only problem I see is that Apple might (and likely will) disagree with some of their potential customers about what functionality is essential.

[eyelidlessness]

Related content: the round Mac Pro

[josephg]

> Not when building large software projects.

While working in rust I am most limited by single core performance. Incremental builds at the moment are like, 300ms compiling and 2 seconds linking. In release mode linking takes 10+ seconds with LTO turned on. The linker is entirely single threaded.

Fast cold compiles are nice, but I do that far more rarely than incremental debug builds. And there’s faster linkers (like mold[1] or lld) but lld doesn’t support macos properly and mold doesn’t support macos at all.

I’m pretty sure tsc and most javascript bundlers are also single threaded.

I wish software people cared anywhere near as much about performance as hardware engineers do. Until then, single core performance numbers will continue to matter for me.

[1] https://github.com/rui314/mold

[PaulDavisThe1st]

My project [0] is about 600k lines of C++. It takes about 5m40s to build from scratch on a Ryzen Threadripper 2950X, using all 16 cores more or less maxed out. There's no option in C++ for meaningiful incremental compiles. Typically working compiles (i.e. just what is needed given whatever I've just done) are on the order of 5-45 secs, but I've noticed that knowing I can do a full rebuild in a few minutes affects my development decisions in a very positive way. I do 99% of my development work on Linux, even though the program is cross-platform, and so I get to benefit from lld(1).

The same machine does nychthemeral builds that include macOS compiles on a QEMU VM, but given that I'm asleep when that happens, I only care that the night's work is done before I get up.

[0] https://ardour.org/

[gchokov]

Like… everyone builds large projects all the time?

[akmarinov]

If you don’t then you don’t really need the top end do you?

[ajuc]

Most people who buy fast cars don't need them and it's the same with computers.

[YetAnotherNick]

By that logic you could build an array of mac mini if you don't care about price/heat.

[semicolon_storm]

What compiler could even make use of 10 cores? Most build processes I've run can't even fully utilize the 4 cores.

[PaulDavisThe1st]

Compilers typically don't use multiple cores, but the build system that invokes them do, by invoking them in parallel. Modern build systems will typically invoke commands for 1 target per core, which means that on my system for example, building my software uses all 16 cores more or less until the final steps of the process.

The speed record for building my software is held by a system with over 1k cores (a couple of seconds, compared to multiple minutes on a mid-size Threadripper).

[spacedcowboy]

I can stress out a 32+32 core 2990WX with 'make -j' on some of my projects, htop essentially has every core pegged.

[ukd1]

Just running the tests in our Rails project (11k of them) can stress out a ton; we're regularly running it on 80+ cores to keep our test completion time ~3 minutes. M1 Max should let me run all tests locally much faster than I can today.

[andy_ppp]

Wow, what is the system doing to have 11000 tests?

[postalrat]

  add(1, 1) = 2
  add(1, 2) = 3
  add(1, 3) = 4
  add(1, 4) = 5
  ...

[pornel]

Rust (Cargo) does, and always wants more.

[jlmorton]

Often a single compiler won't make use of more than a core, but it's generally easy to build independent modules in parallel.

For example, make -j 10, or mvn -T 10.

[destitude]

Xcode has no issues taking advantage of all cores.

[throwawaywindev]

C++ compilers probably will.

[5faulker]

Just when you think things hit the top, another kid's out of the town.