[tpetry]

Now its getting really interesting: In the end you have to compare pricing for a vCore (which is a thread on a cpu) with per-thread performance on AMD vs. Intel. Does anyone know a benchmark like this? Epyc Processors are most often tested on heavy parallelizable tasks and not strictly single thread tasks.

[noahl]

I don't work there any more, but back when I was at Google Cloud we developed our own benchmarking suite, partly to answer questions like this. It's open source, you can run it too: https://github.com/GoogleCloudPlatform/PerfKitBenchmarker

[api]

From what I've seen AMD's recent chips beat (sometimes outright destroy) Intel on multithreaded tasks, but on single-threaded tasks it's still a bit of a toss up and depends on the work load. Intel seems to still come out ahead on some heavy numeric and scientific type work loads, especially if vector instructions are used. The differences are not huge though, and AMD solidly wins on price/performance even in cases where it's a bit slower in absolute performance for single threaded work.

At this point Intel literally only makes sense if you have one of those single threaded work loads where it still excels and you absolutely must have the fastest single thread performance.

[dilyevsky]

Is that with spectre/meltdown/etc protection on?

[imajoo]

AWS patched their hosts back in 2018 which caused a huge shitstorm in terms of performance lost across various workloads..so yes.

https://blog.appoptics.com/visualizing-meltdown-aws/

[dilyevsky]

Afaik amd patches aren’t as penalizing as Intel ones. I have no idea if ^^^ refers to bare metal, bare metal w/ patches or cloud env (unlikely) hence the question.

[imajoo]

The link above is specific to AWS -- hence, "Visualizing Meltdown on AWS" as their title.

[api]

Don't know, but for pure numeric code these mitigations are not (AFAIK) that expensive. The main cost is incurred for any code that is syscall-heavy like I/O.

[dilyevsky]

Pure numeric benches aren’t very useful irl tho. My hunch is with security patches single core will be very comparable

[blattimwind]

These are VMs, the hosts have to run with these mitigations enabled.

[boulos]

Disclosure: I work on Google Cloud.

Performance is a tricky, multi-dimensional thing, so there are many benchmarks that try to map to different workloads. For example, specint is often used for exactly your "single threaded task" benchmark, but if what you work on is numerical computing, you mostly don't care (you want specfp at the least and even that is bad).

Some people seem to really like Coremark these days. Others like specintrate. What kind of application do you care about? I'd guess plenty of folks here can provide a better estimate with that info.

[t3rabytes]

I did some rudimentary testing with AMD vs Intel on AWS recently and found that AMD lacked enough in single threaded perf that it meant they weren’t worth the savings for our workloads (Rails apps).

[theevilsharpie]

AMD-based AWS instances are running on first-generation Epyc processors.

Compared to the second-generation Epyc processors that Google is using, the first generation has lower clock speeds, can execute fewer instructions per clock (particularly in terms of floating-point operations), has substantially less cache, and has a more complicated memory topology that can negatively impact the performance of workloads that aren't NUMA-aware.

In short, your experience with AMD in AWS isn't relevant to Google's offerings.

[actuator]

Care to publish if you have anything stored away from this?

I don't work with Rails anymore but the last Rails app(single threaded, Unicorn) I worked with raw CPU compute was not the bottleneck usually as with most CRUD apps time was mostly spent in I/O. This effect was so pronounced that I had set up most scaling groups on M or R instances as the memory used by the gems was the bottleneck on the number of Rails processes I could spawn in the box without exhausting resources. However I do remember even if CPU was not the bottleneck, moving to a processor with a better single thread performance did improve the median response time at the cost of making the same request throughput costlier.