There are compilation benchmarks in TFA.

Edit: http://www.anandtech.com/show/11244/the-amd-ryzen-5-1600x-vs...

There's a single benchmark for measuring how long it takes to compile Chrome. That doesn't tell, say, the average IDE user how well it'll handle their interactive experience – it's reasonable to expect that to multithread well – or what the workload the original poster specifically mentioned will be like. Many web developers have e.g databases, redis, CSS/JS compilers, etc. running (directly, in Docker, etc.) in addition to the app, and many of those bottleneck on single-threaded performance, and so it's quite reasonable to ask whether that kind of workload benefits from the extra parallelism which is the main selling point for this processor design.

It seems to average 10-20 compiles a day... And it's Chromium compilation. That probably averages 1-2.5 hours per compilation. Compiler as a benchmark depends a lot on moving data and jumps from all the parsing, codegen, dataflow analysis, etc.. It's definitely not a floating point heavy benchmark.

Linux kernel compile times:

http://www.phoronix.com/scan.php?page=article&item=ryzen-180...

Seems like the answer that more threads are better, and Ryzen has more threads.

If you do compiling then multiple of threads are better.

For video editing multi threads is HUGE.

If you have several single thread applications open then multi thread is better. Multiple of tabs multi threads is better.

Most of the time single thread performance is more important.

That's why I upgraded at home from a 6700k to a R7 1700x. My build times went down to like 55 to 65%, so not quite 2x as fast.

No, but you got an 80% improvement for a similar price.

Higher frequency is better. Most web languages are single threaded. Most operations, opening your IDE, running tests are also single threaded.

> running tests are also single threaded

Only if your tests modify global state / aren't thread safe. Good unit tests can be ran multi-threaded.

> opening your IDE, running tests are also single threaded

That very much depends on the IDE and testing framework

Yeah, I'm not sure what IDE they're talking about, but certainly IntelliJ will happily use 800% CPU, causing the fans to spin up impressively, when starting up/reindexing/doing any of the slow things that IntelliJ likes to do.

Glad to learn that the reindexing is multi threaded :)

Yes... and he's trying to say a lot of software out there aren't written multi-threaded because either there wasn't much performance gain or the developers simply choose not to.

Compilation and linting are mostly mono threaded. At least in the languages I use. That is a lot of direct waiting.

> Compilation and linting are mostly mono threaded.

Which languages fall on your list? (Just curious)

I use:

* C (make and gcc can thread)

* Python (no real thread story)

* JS (depends)

* Scheme (usually threads)

C, C++. Compilation can be multi threaded. Linking is inherently mono threaded. A number of optimizations flags are mono threaded (and take very long).

Python. Lint is mono threaded. The virtualenv setup is mono threaded (running requirements.txt).

Java. Mono threaded for package generation (jar files). Not sure about compilation and running tests. Most of Eclipse is mono threaded (last I used it) like indexing and rendering and auto completion.

Outside of that, opening any IDE, tool, application or browser is a mostly single threaded operation. The rendering of most GUI is also single threaded.

> Linking is inherently mono threaded.

This is actually not the case -- modern linkers (e.g., lld) can take advantage of multiple cores.

https://lld.llvm.org/

so can the 'gold' linker.

Interesting -- do you have a link on this?

Make definitely requires a well-specified list of dependencies, meaning that the targets and prerequisites need to specify a DAG from the source files through the intermediates to the final target executable(s). If that's not complete then a threaded make will fail.

Most recursive make systems can't be run in jobserver mode because the graph is not well-specified.

This statement is pretty badly outdated. Modern web tech is just as multi-thread capable as other tech.

It's not. There's a reason Mozilla is pushing Servo.