Slashdot Mirror
Linus Torvalds on Why ARM Won't Win the Server Space (realworldtech.com)
Linus Torvalds: I can pretty much guarantee that as long as everybody does cross-development, the platform won't be all that stable. Or successful. Some people think that "the cloud" means that the instruction set doesn't matter. Develop at home, deploy in the cloud. That's bullshit. If you develop on x86, then you're going to want to deploy on x86, because you'll be able to run what you test "at home" (and by "at home" I don't mean literally in your home, but in your work environment). Which means that you'll happily pay a bit more for x86 cloud hosting, simply because it matches what you can test on your own local setup, and the errors you get will translate better. This is true even if what you mostly do is something ostensibly cross-platform like just run perl scripts or whatever. Simply because you'll want to have as similar an environment as possible.
Which in turn means that cloud providers will end up making more money from their x86 side, which means that they'll prioritize it, and any ARM offerings will be secondary and probably relegated to the mindless dregs (maybe front-end, maybe just static html, that kind of stuff). Guys, do you really not understand why x86 took over the server market? It wasn't just all price. It was literally this "develop at home" issue. Thousands of small companies ended up having random small internal workloads where it was easy to just get a random whitebox PC and run some silly small thing on it yourself. Then as the workload expanded, it became a "real server". And then once that thing expanded, suddenly it made a whole lot of sense to let somebody else manage the hardware and hosting, and the cloud took over. Do you really not understand? This isn't rocket science. This isn't some made up story. This is literally what happened, and what killed all the RISC vendors, and made x86 be the undisputed king of the hill of servers, to the point where everybody else is just a rounding error. Something that sounded entirely fictional a couple of decades ago. Without a development platform, ARM in the server space is never going to make it. Trying to sell a 64-bit "hyperscaling" model is idiotic, when you don't have customers and you don't have workloads because you never sold the small cheap box that got the whole market started in the first place.
Which in turn means that cloud providers will end up making more money from their x86 side, which means that they'll prioritize it, and any ARM offerings will be secondary and probably relegated to the mindless dregs (maybe front-end, maybe just static html, that kind of stuff). Guys, do you really not understand why x86 took over the server market? It wasn't just all price. It was literally this "develop at home" issue. Thousands of small companies ended up having random small internal workloads where it was easy to just get a random whitebox PC and run some silly small thing on it yourself. Then as the workload expanded, it became a "real server". And then once that thing expanded, suddenly it made a whole lot of sense to let somebody else manage the hardware and hosting, and the cloud took over. Do you really not understand? This isn't rocket science. This isn't some made up story. This is literally what happened, and what killed all the RISC vendors, and made x86 be the undisputed king of the hill of servers, to the point where everybody else is just a rounding error. Something that sounded entirely fictional a couple of decades ago. Without a development platform, ARM in the server space is never going to make it. Trying to sell a 64-bit "hyperscaling" model is idiotic, when you don't have customers and you don't have workloads because you never sold the small cheap box that got the whole market started in the first place.
I always found it strange to use an Ubuntu server. Whilst it's okay, and often better than most BSD or other systems, it's not as stable as RedHat. So why so many Ubuntu servers? It's simple: that's what the developers are using. Linus is, as occasionally happens, spot on with this one. If you can't get exactly the same set up locally there's always going to be the odd really difficult debugging case that just takes you too much time to justify. The solution is obvious: start providing ARM Linux laptops with very similar processors to the ones used in servers. I'll buy a few myself.
Assuming you aren't rolling your own thread and atomics libraries, is there a perceivable difference on the API side when moving from x86 to ARM or any other architecture? Hell, if this argument were true, there are enough differences between the various x86 iterations that would make it so that devs want the specific *family* of processors they develop on to be in the servers they use...
I posit there's probably enough of a difference between AMD's x86 implementation and Intel's...
x86 won on price, on the desktop, on the server. That is the simple truth.
As for stability and bugs, cross platform is superior. Bugs that are hard to manifest on one hardware architecture may manifest quite readily on a different architecture. Having worked on various cross-platform projects I've seen the main x86 based dev teams visit the alternative architecture teams (ex PPC) when they are stumped debugging, they eventually appreciated the alternative architectures. A single architecture target allows for longer lived quirky bugs. The simple truth is that cost is more important to many.
This is not to say ARM will be successful in server space, just that it will be about cost and little else.
Motorola on the other hand seemed more willing and eager for PPC to catch on. It didn't work out but you did see some random machines adopt it for short periods. The BeBox, the half backed second chance at Amiga's, random accelerator cards for various obsolete machines etc. The best shot PPC ever had at getting wide adoption was during the short period Apple licensed Mac clones in the mid 90's. Jobs shut down when he returned. Regardless of whether that was the right move it did mean PPC would never be a serious contender to x86.
There are PC class power systems you can purchase but they are all made by integrators I have never heard of. Not sure how well I would trust them. That's likely a factor as well. And of course, by the time you could get such systems the battle was long over.
Why not just build a system around a Crusoe processor at home and let it emulate anything you want to eventually run the software being developed on?
Seems pretty cut and dry to me.
load "linux",8,1
At some point in the near future, Macbooks will start coming with custom Apple designed ARM processors instead of Intel chips.
At that point, the trendy urban hipsters buying these Macbooks will be developing on ARM and will want to deploy their code on ARM based servers. Your local IT department might say no, but I'm sure that the cloud hosting providers will gladly oblige.
"Develop at home" is really a proxy for "develop/deploy on cheapest". What applications, what software stacks, care about the underlying hardware architecture? If cloud based servers ran non-x86 hardware few would notice or care. If cloud server costs for non-x86 hardware were cheaper and performed adequately they would get used. x86 Linux won because it was cheaper than the traditional Unix vendors with their proprietary *nix RISC based platforms. Similar on the workstation side. The shift from RISC *nix boxes to x86 Linux was overwhelmingly about cost, almost no software cared which it ran on.
Linux x86 to Linux ARM would be a virtually unnoticeable transition for nearly all. Again assuming adequate performance for the money. It was about price in RISC *nix days, it will be about price in ARM days.
Why not use smartphones as testing platform. That is ARM everywhere
I'm currently hoping the Pinebook Pro does very well when released later this year. I'm already planning on purchasing one for FreeBSD ARM development. The specs still are not the best, but are decent enough for some interesting development tasks. A portable ARM laptop with a hex-core processor, 4GB RAM, 64/128GB eMMC, Mini-PCIe with NVMe support, 1080p ISP display, 10,000 mha battery, and USB-C that supports charging + 4k/60hz video. This thing will be a little mini beast for $200. Most of programming is reading/writing code more so than executing it, so I believe this should be plenty powerful for solid web development and system service programming. This laptop NEEDS to do well to show the industry as a whole that these are the type of devices we WANT.
Most of the web applications these days are developed using frameworks/languages that are cross platform (like node.js, .net core, java..). With these frameworks and app containers, it doesn't really matter what OS or hardware is running it. Server farms will move to a more efficient way to manage their server loads. I think performance/power and performance/price will be critical in deciding who wins. You can't rule out ARM right now.
once laptops (The preferred being mac) and datacenters have ARM options, which is provably happening, then your x86 argument dies horribly.
This, and a few more reasons:
(1) Server-side software is a more limited set than desktop or mobile. For instance, no dependencies on graphics toolkits.
(2) More and more software is written in higher-level languages and running on virtual machines/interpreters, such as Javascript and Python. It sounds like a joke, but there are major web frameworks written in JS. This further narrows down the set of software you actually have to port.
Escher was the first MC and Giger invented the HR department.
IBM is buying RedHat for $34 billion.
2018 RHAT revenue was $2.9 billion. Canonical last year had revenues of $125.97 million. That's a 20x multiple.
The market share follows a similar trend.
I wish I was "losing" by having a 20x multiple.
I remember yelling profusely at the Amiga community that they should drop all this PPC nonsense and just adopt x86. The community insisted they didn't want Intel Inside, but more importantly, the people who owned the rights to AmigaOS were scared to death that people would pirate the OS and run it on generic hardware, so they insisted on re-badging buggy PPC dev boards (which in one case, couldn't even use disk DMA correctly).
Same mindset as the 80's, with predictable results.
Ironically, fast 68K cores implemented on FPGAs is now coming into vogue, so PPC might very well be dead even in the stubborn Amiga community.
Not just single thread performance, performance per watt in the 80+W TDP area is actually really advantaged toward AMD and Intel. The ARM vendors did a fantastic job of typical power consumption in frequent sleep and providing serviceable performance in low power envelopes, but have not yet demonstrated good performance in high power usage environments.
Part of it is the relative lack of experience, a great deal of it is that Intel has invested in all sorts of third party and first party compiler and library performance for x86. ARM could catch up, but as of now it seems few companies even have the ambition to try, and are refocusing on the embedded space which is less 'glamorous', but sells tons of volume.
XML is like violence. If it doesn't solve the problem, use more.