HNHacker News
TopNewBestAskShowJobs

twotwotwo

1,841 karma · joined June 24, 2012

submissionscomments
twotwotwo··on Too Much Crypto [pdf]
Yes, I know Aumasson's a highly respected professional and followed the contests, and am even, like I said, kinda sympathetic to the idea that keeping a big margin for unknown unknowns may make less sense than it once did.

What's the practical play here though? I guess lower-round ChaCha-Poly1305 TLS cipher suites could be worth it for users without hardware AES. I suspect even less-aggressive folks would be comfortable enough with ChaCha12 instead of 20 (e.g. Android already uses it to encrypt storage when there's no AES acceleration).

But trying to move to reduced-round variants of every already-standardized primitive would be a lot of effort to, for most applications, move symmetric crypto from one tiny amount of resource use to another (even if it's much smaller in relative terms!).

I do realize that people care a lot about performance, that there are applications either building on tiny microcontrollers or handling redonkulous data flows, and that any possible bit of flexibility could help someone. Still seems fair to ask: if the broad change in perspective Aumasson wants does happen, is it really going to change much about crypto in the wild soon?

twotwotwo··on Too Much Crypto [pdf]
And man, the rounds we have are not so expensive. Even cheap phone SoCs tend to have hardware-accelerated crypto. Some server chips have AES-128 in the memory controller, inspired by a feature console makers wanted: https://www.crn.com/news/components-peripherals/amd-s-xbox-p...

(AES-128 happens to also be one of the algorithms he thinks has the least "extra" margin, for whatever that's worth. Bigger difference for ChaCha.)

I do have some sympathy with the idea there's less uncertainty around long-studied symmetric algos than there was long ago, so the sensible margin is smaller than it used to be. Symmetric crypto's certainly moved closer to the good kind of boring since the AES competition and e.g. thorough study of RAX ciphers and other minimal primitives.

But from another angle, we have a system that's working pretty well, including in cost and performance. Given interoperability, etc. seems like there's a high bar to mess with it in the name of making a few more super-small-scale uses of crypto possible or cheaper.

twotwotwo··on Windows 95 UI Design
The old desktop approach had some cool things. List views tended to support common operations, e.g. sorting, drag-and-drop, multiselection, common ways to do renames and type-ahead-find. Tree views had some standardization, too. Crowded menus/toolbars could be ugly, but you could discover a lot of functionality going through them. Right-click tended to expose a set of verbs.

These things often exist now or have an analog (e.g. long press is right-click in mobile UI), but not everywhere and not always done the same way. Mobile has some inconsistency; the Web has a good bit.

The modern has plenty of its own UI/UX things--URLs and the Back button for the win, dev tools/view source are awesome, and certain cool things can come from services not living entirely on your device. Something like hiding clutter at the cost of discoverability is a win for many people.

Still think it's interesting to compare and think about what can be usefully brought forward from the past.

twotwotwo··on Putting Stuff in a Proliant Dl325
Don't know a place to get it prebuilt, but building an EPYC "desktop" can be a lot like building a TR one. There are ATX server mobos. TR4 coolers should work with EPYC; Noctua explicitly says theirs do, and the physical socket and TDPs match.

You might want TR for the higher frequencies, though. I guess you could use EPYC for a very expandable 16C machine, or to pay a bit less for lower clocks, though I don't know if it ends up worth the fuss.

twotwotwo··on Why databases use ordered indexes but programming uses hash tables
Indexes on things that’re correlated with time (ID, timestamp) tend to concentrate recently added data towards the “end” of the table/index, which is a big help when you have years of data but mostly people are asking about the last few weeks.

It gets a couple sentences in the post, but prefix searches are key (ha!): a sorted index on (foo, bar, baz) helps not only searches on all three attributes but also foo=x and bar=y or just foo=x. It can also be useful when you want to look things up by a prefix of an individual column: filter to a given day or month using a timestamp index, or filter to errors reported from client version 3.2.x. As a “covering index” it can somewhat help with queries that limit to foo=x and do something with bar (filter on it, return it, sum it, etc.). Finally, it helps with multiple scenarios for aggregation, not only searching: a timestamp index can let you get a count of orders by day, hour, or second without needing to make another temporary table/index.

Often the crucial thing for keeping a DB humming is not getting the last couple percent out of already-fast operations but making sure you don’t have any disastrous queries, so an index being versatile for many kinds of search is especially valuable.

Related to that last point, databases are trying to prepare for queries that haven’t even been written yet, while when you’re coding some algorithm that involves a hashtable, you already know exactly what lookup you’re going to do a few lines later. That on its own is going to push you towards more flexible types of indexing.

(Crossposted from https://lobste.rs/s/68dgox/, where other folks have some good comments.)

twotwotwo··on Help me ask why you didn't just
It's not only a phrasing thing.

The revised phrasings are better, but if someone's spent "a week or a month or maybe years" on a problem, consider asking what they think are the tricky tradeoffs and so on and give them a minute or a few sentences or an email or whatever to tell you before you launch into anything about your idea.

Not for politeness, but because if they're knee-deep in the problem they probably learned something you don't already know about it. It may illuminate why your idea wouldn't've made sense before you ask. You may get another, better informed idea. You may still have the same idea but learn something on the way there. It's a gamble worth taking if possible.

And, sure, if there's no time for that kind of convo, there are ways to politely offer your intuition that X might have worked, and that can be a shortcut to finding at least one thing that wasn't in your mental model of the problem. But, if you think they understand the problem much more deeply than you do, offering them a more-or-less open-ended chance to give you a download of what they've learned is a smart move.

twotwotwo··on Go memory ballast: How I learnt to stop worrying and love the heap
And there are other situations where if you overshoot some memory limit, you get killed or the OOM killer kills some random thing (ugh) or you just have performance degradation (swapping, crowd out caches, whatever). Often better to suffer n% more GC CPU usage than to deal with that. So min/max heap are both important in different scenarios.

A blog post from someone working on .NET suggested "the user shouldn't have to know about GC internals" as the heuristic for when you have too many knobs, which I like. The user knows some things that the runtime does not about their needs in terms of RAM vs. CPU use, and it seems reasonable to have ways to communicate that.

(One other thing the user knows is their relative priorities for having a consistent level of CPU used by the GC vs. minimizing the absolute amount of CPU used. I think Go is hard-coded to target about 25% CPU use during a collection right now. Not sure we're ever getting that knob, though.)

twotwotwo··on Go memory ballast: How I learnt to stop worrying and love the heap
FWIW, there's a related open issue about adding a minimum heap size for situations like this, where you don't care about wasting a bit more RAM but do care about the GC work: https://github.com/golang/go/issues/23044

It references a patch to add a SetMaxHeap call, which could help in these kinds of situations too.

twotwotwo··on Syntax Highlighting Is Backwards (2018)
The most intriguing version I've heard of this was also based on the feeling that it's already easy to scan for keywords and structure; they went a different direction, using color to make different things (especially confusable ones) look different: https://wordsandbuttons.online/lexical_differential_highligh...

I don't feel like I know how/if highlighting helps, so all I can really say is seems interesting.

I think some of the problems commenters are having with the color scheme are because the site has a dark mode and contrast might be worse when it's on. Maybe in that mode text colors meant for a dark background are still getting applied in the white-backgrounded code fragments.

twotwotwo··on Don’t Rush Quantum-Proof Encryption, Warns NSA Research Director
I feel like 1) that is the key quote, 2) it's true, 3) it's also setting the bar too high for current efforts.

The first go at a post-quantum public-key crypto standard may in effect be (a public-key analog of) the DES that'll need be replaced with an AES someday. But provided we can get something that isn't a step backwards in classical security (so, well-studied problem) and doesn't fall to Shor's algorithm or any other thing we can find in a few years, that's way ahead of where we are now.

We may be feeling around in the dark because we don't know much about quantum computing, but we may also have to do that if we want reasonable security when the first big quantum computers show up.

twotwotwo··on SimplyNUC Unveils Sequoia: AMD Ryzen V-Series-Based UCFF PC
Alas, the A300 won't even boot headless with a non-APU: https://www.reddit.com/r/Amd/comments/bk3nui/has_anybody_tri...

Re: the general idea of smallish, headless Ryzen boxes for a cluster, Intel kind of blurs the server vs. consumer distinction with the entry-level Xeon E chips, and I can sort of imagine a similar-shaped niche for low-end AMD servers. There's some ECC functionality in the Ryzen silicon (https://www.overclock3d.net/news/cpu_mainboard/amd_confirms_...), and although the PCIe/RAM capacity isn't near EPYC's, seems like enough for the price to be interesting to somebody.

twotwotwo··on GC Fun at Twitch
There is internal work on a SetMaxHeap API: https://github.com/golang/go/issues/23044 (there's a review of related code at https://groups.google.com/forum/#!topic/golang-codereviews/b... ). It isn't perfect (notably, heap size and process size as seen by the OS are not identical) but seems like a step up from ballast or other workarounds.

In the issue thread Caleb Spare also proposed a minimum heap size so that you get GOGC-ish behavior once your app uses enough RAM, but don't have constant GCs with a tiny heap.

There's definitely a common issue where the GOGC heuristic doesn't take advantage of situations where it can collect less often but still remain in the "don't care" range of memory use. (CloudFlare talked about the same thing making benchmark results weird: https://blog.cloudflare.com/go-dont-collect-my-garbage/ )

And there can definitely be situations where GC'ing a bit more would be worth it to keep a process under an important memory threshold to avoid swapping or OOM kills.

The designers famously don't want too many knobs, but some other ways to convey user priorities to the runtime could certainly save users from some awkward workarounds and fiddling w/the existing knobs.

twotwotwo··on We shouldn’t blame ourselves for the Linux desktop’s microscopic market share
I'm not hugely disappointed with Linux's marketshare per se, because that doesn't affect a Linux user's life as much as you might think. It does what I need it to, stably, and I rarely run into old annoyances like hardware compatibility or incompatibility with specific tools I need for work. It's encouraging that Mac OS and now Windows (with WSL) have made some effort to become more reasonable Unix dev environments too. The dollar cost of the OS on new machines doesn't seem intolerable; you can do a lot with a cheap Chrome OS or Windows device.

There are problems today that might not exist in a more Linux-y world, especially the remarkable power of a few huge companies to shape users' computing experiences. On the other hand, if Linux had had some huge commercial backer, whatever popular distribution won could have ended up with similar issues. In any case, my preferred desktop "winning" is not the only or best solution to those problems; users get some support from market forces (which I think we can partly credit for useful cheap devices and Microsoft's transformation) and where they don't help, well, regulation, including antitrust regulation, is always out there.

twotwotwo··on AMD Q4:16-core Ryzen 9 3950X, Threadripper Up To 32-Core 3970X
Using the ASRock A300 today and already pretty happy with it (small, quiet, reasonable cost, gets the work done), though of course agree the next APUs should be a noticeable step up.

It'd've been nice if ASRock's micro-STX formfactor had taken off and gotten an AM4 variation (http://www.asrock.com/nettop/Intel/DeskMini%20GTXRX/index.as... ). It's a mini-tower bigger than NUC or the A300 but smaller than mini-ITX. Compared to mini-ITX, it takes an MXM GPU instead of having a full-sized PCI slot and uses an external brick PSU. The extra benefit on the AM4 side would've been that even a weak dGPU allows using non-APU chips, at least up to the supported TDP.

twotwotwo··on AMD is having its day
I'm interested to see it but I expect it'll be just a noticeable step up, not a blockbuster. The process and focus on IPC seem like good things for power consumption. But it seems like there's a ton of work Intel's done to optimize sleeps/twiddle clock freq/etc. for the thin-and-light laptop use case, and I'm not sure AMD is close to catching up with that.

They could always surprise me. (TSMC does fab power-sipping mobile chips too!) I just don't have super high expectations.

twotwotwo··on AMD Rome – is it for real? Architecture and initial HPC performance
The internal Intel competitive analysis is not bad here: https://www.techpowerup.com/256842/intel-internal-memo-revea...

I don't know about µarch details but a bunch of bigger-picture things have contributed to AMD's run:

Spinning off their foundry ops led to AMD getting to use TSMC, who turned out to have a great process node at 7nm. Indirectly, it probably helps that other huge customers mean TSMC can amortize their process development costs across all of them.

The chiplet approach with a separate I/O die has various advantages:

- The Zen 2 chiplet is identical from the cheapest client CPU to the most expensive server CPU. Surely reduces complexity, and silicon that won't work in a server part might work in a client chip or whatever.

- Relatedly, binning 8-core chiplets is way more forgiving than binning huge monolithic CPUs like Intel's doing; with AMD lots of cores and high perf doesn't require a huge, uniformly near-perfect die, just enough chiplets that meet the spec that you can glue together.

- The I/O die is on a very mature, probably cheaper GloFo process, which may have made it less costly for AMD to offer interesting features on the I/O side (PCIe 4 and 128 lanes even for the cheapest server part, AES-128 in the memory controller, etc.).

Won't happen this gen, but I kind of expect Intel to eventually use some version of chiplets for their larger parts. They're talking about their advanced stacking/packaging tech, so not totally outlandish. Short-term they do have a two-die Cascade Lake mega-CPU planned, but I mean more broadly.

One cost of chiplets is in higher DRAM access latencies. AMD's done things to try and mitigate that, including just using lots of L3 cache. From benchmarks it seems to work.

The Intel analysis also mentions their shift to higher-margin parts as important.

I don't know how critical it is to the story but AMD also did some deals that may've given them resources to invest in their designs, like the GloFo spinoff, the deal to sell Epyc 1 clones in China, and the deals to produce Xbox and Playstation chips.

Finally, Intel would ordinarily have their own progress that would make AMD look comparatively worse. But 10nm stalled an incredible amount of time and Intel's post-Skylake core design, Sunny Cove, depended on it.

twotwotwo··on Frugal Computing
In a cloud context, something like AWS spot instances or GCE preemptible instances is a neat tool for this specific niche of minimizing cost when you can accept delays.

The context: providers need more instances than will sell at list price, so they sell access substantial discounts if you accept that a customer paying full fare can bump you out. (Note instance shutdowns might be correlated, not random.) I've definitely heard of folks running tools like Spark that way. From the software angle, being able to efficiently use various types of machine and being able to minimize work lost when a worker dies (i.e. to checkpoint) can help there.

I've heard of analogous setups for companies that own their boxes, e.g. Google's Borg paper talks about the tricks they do to make production and non-production jobs share the same box effectively.

I think sometimes cost optimization will lead you to counterintuitive answers. For example, obviously the post is right that memory is pricier than disk is. (Also, external memory algorithms are cool; more people should read about them.) But when box time itself isn't free, and more RAM or faster storage allows you to use less of it, the pricier computing resources can end up paying for themselves. Like a cost version of the race to idle in power management.

And the (good) discussion of the costs of going distributed may lead you to want to have big enough boxes available to allow you to distribute fewer jobs, even when those boxes cost (more-than-linearly) more than smaller ones.

I'm not saying this to advocate for a particular strategy; more want to say the right approach can depend in super tricky ways on the specific workloads and constraints you have.

twotwotwo··on Einstein Analytics and Go
The post dates the rewrite effort as happening in 2016-7. In the past couple years escape analysis has gotten a lot of effort (https://github.com/golang/go/issues/23109) and there's also now mid-stack inlining (https://github.com/golang/go/issues/19348) which obviously can be useful in itself but also help escape analysis and other optimizations work.

Does anyone know if there's any big picture work on GC throughput in progress? The idea of the ROC (fast freeing of memory never shared between threads on goroutine exit) was canned since it regressed on some workloads and I'm having trouble finding signs Austin's idea with hashing memory landed either. A moving GC or a read barrier seem mostly out because they can hurt other things (C interop, performance of code that doesn't allocate much). Though they seem to have addressed pauses quite well, and lots of code out there isn't GC-heavy, it still seems like a key area where it might be possible to give a "free" throughput win to existing code.

twotwotwo··on Einstein Analytics and Go
I see why you'd do perf tests as well (you might fail to annotate everything that could make your function run slowly), but a static analyzer that looks at -gcflags -m output does sound like a super cool idea--direct way to check if your intuitions about the code and its compilation are right.
twotwotwo··on Web Graphics Done Right
A potential future option I only just learned about is JPEG XL (not XR!) which is proposed as a royalty-free successor to the JPEG we know. The draft is at https://arxiv.org/abs/1908.03565 and a little bit about what it has and why is at https://www.spiedigitallibrary.org/conference-proceedings-of... (but I haven't found nearly as much public detail on tools, reasoning behind choices, etc. as there is for e.g. AV1).

The most interesting bit of it is that it contains a JPEG1 recompressor that saves about 20% space but allows exact reconstruction of the original file. It uses more modern entropy coding and goes to more effort to predict coefficients than JPEG1. It has almost exactly the same gains as, and sounds a lot like, Dropbox's Lepton, described here: https://blogs.dropbox.com/tech/2016/07/lepton-image-compress... .

Seems like a big deal to plug seamlessly into all the JPEG-producing stuff that exists, without either doing a second lossy step (ick) or forking into two versions when you first compress the high-quality original. 20% off JPEG sizes is also a bigger deal than it may sound like; totally new codecs with slower encodes and a bucket of new tools only hit like ~50% of JPEG sizes. As Daala researcher Tim Terriberry once said, "JPEG is alien technology from the future." :)

For JPEG XL's native lossy compression, it has some tools reminiscent of AV1 and other recent codecs, e.g. variable-sized DCTs, an identity transform for fundamentally DCT-unfriendly content, a somewhat mysterious 4x4 "AFV" transform that's supposed to help encode diagonal lines (huh!), a post-filter to reduce ringing (that cleverly uses the quantization ranges as a constraint, like the Knusperli deblocker: https://github.com/google/knusperli ).

Interestingly it does not use spatial prediction in the style of the video codecs. A developer in a conference presentation mentioned that it's targeting relatively high qualities equivalent to ~2bpp JPEGs -- maybe spatial prediction just doesn't help as much at that level?

Don't know if AV1-based compression or JPEG XL will get wide adoption first, but either way we should actually have some substantial wins coming.

twotwotwo··on On Sharding
> But the cache is a distraction. The performance you’re going to get will depend on your record sizes and update patterns and anyhow you probabl don’t care about the mean or median as much as the P99.

True your 99th percentile slowest requests won't hit the cache, and certainly that caching won't solve all your scaling difficulties.

However, keeping requests for commonly-needed data away from (say) a DB cluster decreases the load on it at a given level of throughput, and that can be good for P99, and (as the post notes) caching can specifically help with super-hot data which can cause problematic hotspots in some sharding strategies.

Obviously situations vary and there're limits, but a cache seems like a legit tool, not just a band-aid, for a decent number of situations.

twotwotwo··on Ristretto: A High Performance, Concurrent, Memory-Bound Go Cache
Oh, fascinating. My intuition re: size was that you'd look at worth per byte for something like query results, a whole different kind of thing from the CDN use case that's been studied.

Makes me wish I could justify adding instrumentation to our 'memoize' wrappers at work, although our caching doesn't really match the use case for something like Ristretto or Caffeine. (Little enough stuff and the latency of a networked cache is fine for us, so "just set aside lots of RAM on some cache servers" works well enough.)

twotwotwo··on Ristretto: A High Performance, Concurrent, Memory-Bound Go Cache
TinyLFU is kind of magical--most of the win you'd get from expensive tracking of key frequencies, in much less space. The bloom filter in front seems like a clever hack.

Not an expectation/criticism/etc. of Ristretto, but out of curiosity, does anybody know of work about making the cache aware of the expected cost of a cache miss for each key?

To spell out what I mean: if I'm sending a query result to the cache, I could also pass along how long the query took to run. Then, in theory, the cache could try to drop keys with low (expected number of fetches * expected cost per miss), not just low (expected number of fetches). Of course that's rough/imperfect, and for some caching scenarios the miss cost doesn't vary by key.

I guess mostly the question is if it's enough of a help to justify the metadata+complexity, which I guess requires a trace of gets/sets from something that has miss costs that vary.

The intuition is just that now that we're pretty good at optimizing hit rate, maybe expanding the problem to "minimize total miss cost" could be an interesting direction for the use cases where there's a difference.

twotwotwo··on AMD Ryzen Threadripper 3000 32-core CPU is more bad news for Intel
I don't really hard-disagree with any of that; we're all guessing. The co. sending chiplets where they fetch the most also doesn't seem outlandish as a factor, though.

FWIW, here's the price-per-core chart for the whole second-gen server line:

https://www.servethehome.com/wp-content/uploads/2019/09/AMD-...

(Doesn't factor in voltage/freq needs for different SKUs, some of them needing fully-working chiplets, etc. Still.)

The low pricing on the 7282 and a few others is interesting, too. Wonder if it's a factor that it can use partially-working chiplets since the server I/O die can take up to eight chiplets and the client die only two, or if that's totally unrelated.

twotwotwo··on AMD Ryzen Threadripper 3000 32-core CPU is more bad news for Intel
Worth noting AMD just announced that the first third-gen Threadripper will come out in Nov with 24 cores, and the planned 16-core mainstream chip (the 3950X) is delayed to November: https://www.tomshardware.com/news/amd-ryzen-9-3950x-delay-la...

A 32-core chip is still almost certain to show up, since benchmarks have leaked, and folks have also leaked some pics of 3950X's and packaging, but I guess supply/demand have kept everything from coming out yet.

As the Tom's post notes, server and client chips use the same chiplets, so it could be that most of the higher-binned ones are going to server parts; some are higher-margin (7742 is almost $100/core, vs. 3950X under $50/core) and plausible there're some enterprise orders (AWS etc.) getting priority. I wonder if they tightened the binning for the 3950X to respond to the fuss over turbo, too.

I had never really considered everything that goes into getting to that SKU/price list and launch date: you don't really know how much supply you'll have at various perf levels, or what demand there will be for what at what price, and if you don't exactly match them you might end up losing money by underpricing, by having to nerf good silicon to fill highly-demanded lower-end SKUs, or by having a shortage that makes customers go elsewhere. (Plus vendors don't just have the public SKU list, they're working out contracts with OEMs/other big customers. And who knows what the competition will do.) High stakes, and practically speaking no backsies; seeing how upset folks are about turbo clocks, imagine if AMD announced a price hike. Glad it's not my job.

twotwotwo··on Zen 2 Missives – AMD now delivering efficiencies that are double that of Intel
Yeah. I bet part of why there's so much L3 per core group is that it's really expensive to go further away.

Seems like there're at least two approaches for future gens: widen the scope across which you can share L3 without a slow trip across the I/O die, or speed up the hop through the I/O die. Unsure what's actually a cost-effective change vs. just a pipe dream, though.

twotwotwo··on A Deep Dive into AMD’s Rome Epyc Architecture
I think the tech press still tells us what they can, and stuff like execution ports, reorder windows, etc. is still publicly disclosed. AT talked about what was publicly said about Zen 2 (https://www.anandtech.com/show/14525/amd-zen-2-microarchitec...) and Sunny Cove (https://www.anandtech.com/show/14514/examining-intels-ice-la...). And their reviews do try to report the top observable results (memory latencies, relative performance on different kinds of task, power/clock info) and all that's arguably of more practical importance to lots of folks anyway.

There's also just the trend of modern designs being tricky enough it's harder to infer as much about them and harder to write accessibly about what you do know; it's not super easy to figure out and describe, say, modern branch predictors simply because they're all layering a lot of strategies on each other.

For example, from Haswell on, Agner Fog essentially said Intel's large-core branch predictors are good at lots of things but there's not much he can say about how they work (p29 at https://www.agner.org/optimize/microarchitecture.pdf). Writing code to beat Cortex-A76 prefetchers, AT's Andrei Frumusanu had difficulty fooling them with anything other than essentially-random access patterns and compared them to "black magic" (https://twitter.com/andreif7/status/1102230575522430977). These aren't just random folks saying "wow, CPUs are complicated"; they successfully figured lots of stuff about past generations of CPU.

AMD did reference the TAGE family of branch predictors, which there's lots about in public literature. There might be some broadly interesting stuff in the vendors' contributions to gcc/LLVM (machine models and arch-specific optimizations).

Maybe ARM implementors talk a little more about their stuff? That might have something to do with the dynamics of the relatively open/diverse market for ARM SoCs versus the long-running one-on-one-ish x86 rivalry.

Hard to boil all that down to a single point, but if AMD and Intel want to talk more about the guts of their products, I'm sure plenty of grateful wonks would lap it up. :)

twotwotwo··on AMD Rome Second Generation EPYC Review: 2x 64-core Benchmarked
Two more thoughts:

- A slide in AMD's presentation suggested 64C would cost $7k, but that's for the top two-socket-capable version. If you "just" want 64C, not 2x64C, there is a $4.4k single-socket 64C part. Or if the RAM/PCIe capacity of two sockets is useful, you can get two 32C parts, and those start at $2k each. Makes pricing look better at 64 cores.

- Since they turned on most everything on the I/O die for all parts, seems possible to build boxes with lots of RAM and I/O but as little as 8C or 16C ($500 or $1k) of CPU. Of course, balance tends to be nice, but the ability to make it as lopsided as you want could be relevant for applications that are very RAM/IO heavy (caching), or if you're running a commercial DB where you pay by the core. Neat.

twotwotwo··on AMD Rome Second Generation EPYC Review: 2x 64-core Benchmarked
Right, depends on the things AT mentioned, but also on execution: whether the the issues with 10nm are over (now that they've shipped some chips) or if they'll also slow the scale-up to server-sized dies. Intel moving to chiplets could certainly mitigate that risk some, with tradeoffs similar to the ones in EPYC.
twotwotwo··on AMD Rome Second Generation EPYC Review: 2x 64-core Benchmarked
Page 4 (https://www.anandtech.com/show/14694/amd-rome-epyc-2nd-gen/4) lines up AMD's prices, core counts, and frequencies with Intel's. AT says all these have 128 PCIe 4 lanes and support up to 4TB RAM aper socket.

Intel's own competitive analysis figured competition in servers "is likely to be the most intense in about a decade" (https://www.techpowerup.com/256842/intel-internal-memo-revea...). Sounds about right.

The AMD presentation had announcements from Azure and GCP but not Amazon.

How soon Intel gets Ice Lake ready for servers seems pretty relevant here.

← PreviousPage 7 of 19Next →