4 ms·

Per core performance is the most interesting metric. Edit: for relative comparison between CPUs, per core metric is the most interesting unless you also accoun

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.

5faulker 5y ago
Just when you think things hit the top, another kid's out of the town.
PaulDavisThe1st 5y ago
Not when building large software projects.
- gchokov 5y ago
  Like… everyone builds large projects all the time?
  - akmarinov 5y ago
    If you don’t then you don’t really need the top end do you?
    - ajuc 5y ago
      Most people who buy fast cars don't need them and it's the same with computers.
- YetAnotherNick 5y ago
  By that logic you could build an array of mac mini if you don't care about price/heat.
- semicolon_storm 5y ago
  What compiler could even make use of 10 cores? Most build processes I've run can't even fully utilize the 4 cores.
  - throwawaywindev 5y ago
    C++ compilers probably will.
  - spacedcowboy 5y ago
    I can stress out a 32+32 core 2990WX with 'make -j' on some of my projects, htop essentially has every core pegged.
  - jlmorton 5y ago
    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.
    - deleted 5y ago
      [deleted]
  - PaulDavisThe1st 5y ago
    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).
  - pornel 5y ago
    Rust (Cargo) does, and always wants more.
  - destitude 5y ago
    Xcode has no issues taking advantage of all cores.
- ur-whale 5y ago
  > 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 5y ago
    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 5y ago
      Related content: the round Mac Pro
- josephg 5y ago
  > 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 https://github.com/rui314/mold
  - PaulDavisThe1st 5y ago
    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/ https://ardour.org/

5faulker 5y ago

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

PaulDavisThe1st 5y ago

Not when building large software projects.

gchokov 5y ago
Like… everyone builds large projects all the time?
- akmarinov 5y ago
  If you don’t then you don’t really need the top end do you?
  - ajuc 5y ago
    Most people who buy fast cars don't need them and it's the same with computers.
YetAnotherNick 5y ago
By that logic you could build an array of mac mini if you don't care about price/heat.
semicolon_storm 5y ago
What compiler could even make use of 10 cores? Most build processes I've run can't even fully utilize the 4 cores.
- throwawaywindev 5y ago
  C++ compilers probably will.
- spacedcowboy 5y ago
  I can stress out a 32+32 core 2990WX with 'make -j' on some of my projects, htop essentially has every core pegged.
- jlmorton 5y ago
  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.
  - deleted 5y ago
    [deleted]
- PaulDavisThe1st 5y ago
  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).
- pornel 5y ago
  Rust (Cargo) does, and always wants more.
- destitude 5y ago
  Xcode has no issues taking advantage of all cores.
ur-whale 5y ago
> 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 5y ago
  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 5y ago
    Related content: the round Mac Pro
josephg 5y ago
> 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 https://github.com/rui314/mold
- PaulDavisThe1st 5y ago
  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/ https://ardour.org/