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.
"IBM on Why Intel Won't Win the Server Space 2: Electric Bugaloo"
Ezekiel 23:20
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...
That would prolly because x86 draws a lot more power than ARM
Or at least it use to
http://progressquest.com/spoltog.php?name=Son+Of+Son+Of+DarkRookie
When you can't try out software on some cheap commodity hardware, it never even gets to the cost-benefit analysis. Fronting tens of thousands of dollars just to try out a software-hardware combination is a non-starter in almost any company. x86 wins because the difference between a vm running on a dev's/sysadmin's laptop and one running in a VMWare or Hyper-V architecture is almost non-existent - they know what they're getting before they've spent any money.
At least ARM has some netbooks floating around with the architecture. IBM didn't bother to try and keep Apple on their architecture, and that has hurt the ability to court new customers.
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.
It seems to me that mobile apps wouldn't be a thing either if this logic was true.
Laws are rules for the court, but merely a bottom bar to hit for life. Think beyond laws in your actions always.
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.
ARM is a computer construction kit, not a platform, just like Android is a firmware construction kit, not an OS. Every ARM system needs its own special Linux distribution. As long as that doesn't change, there's no threat to the x86/x64 world. Besides, ARM is just slow compared to x64. Yes, it uses less power, but it also does less. I use small ARM servers for very light workloads, but that's really all they're good for.
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.
this. I do all my development in the cloud. The only difference between the dev box and the prod box is the resources (CPU, memory...). If they swapped it for arm tomorrow it would probably be just fine.
Nullius in verba
Sorry Linus, but that's bullshit and here is why:
Already in all phones. They're not x86. Apple is moving to ARM. Windows is ported/ing to ARM. So that's that side of it more or less done.
Datacenters, yes, less power and heat? Yes please. So that's a move to ARM (Scaleway, et al are already doing this).
So once laptops (The preferred being mac) and datacenters have ARM options, which is provably happening, then your x86 argument dies horribly.
Lets face it. x86 is a turd, and people need to stop trying to polish it. ARM is a breath of fresh air.
I sure as hell don't develop android apps on an android device. I have no problem developing for arm devices from my pc. Been doing it for years now.
What if you also develop and test on the cloud on the same platform as your hosting environment? Might that be the reason Amazon bought Cloud9 http://c9.io/
A lot of hosted applications, especially those where the heavy client lifting has been moved client-side (Angular, React, etc.), could be described as accept parameters, call a database based upon those parameters, organize data into an acceptable payload and return that payload. It's hard to see why these would be dependent upon x86. Same for ETLs. If the power consumption/cost argument for ARM servers is really as compelling as being advertised, there might be something there.
ARM may not be a fit for everything (speech and image recognition, bitcoin mining, etc.), but there is probably a lot of code in NodeJS, Python, etc. that would probably run fine. VMs and even containers can be set up as ARM, and mitigate a lot of the whole "the server doesn't match my home rig" concern raised. Risk can be further mitigated with adequate unit and integration testing. Load starts becoming a more significant variant, but adequate testing can mitigate that risk as well.
I wouldn't discount the possibility of government stepping in and putting more restrains and regulation on power consumption of the larger data centers. If that were to happen, the costs to run x86 hardware at less-than-full capacity/inefficiency could become significant.
Then why are we not seeing Intel rule the mobile world then? I disagree.
Several reasons.
1.) Battery draw. AMD_64/x86 is a big power-hog and eats battery like no tomorrow.
2.) As a corollary to 1.) thermal output is insane no one wants to hold a flat-iron to their face to make a call. Thermodynamics is a nasty bitch all of that battery draw has to go somewhere mostly as heat.
3.) Inertia, arm has been in use for embedded devices including dumbphones and feature phones long before smart phones where a thing. Then iPhone. (no not Cisco Systems iPhone, the fruity one) Apple was the only game in town that people wanted (yes blackberry and palm were first but no one wanted them) and it only came in ARM. Then Android came out in ARM, (Sure support for other platforms was there eventually but damage was done) and it abstracted it all away behind a Java virtual machine.
4.) Local debuging. Cloud servers are off-site and not something you can sit next to a diagnoses locally by their nature. While I can plug a mobile phone into my desktop/laptop and debug it over usb with it in my hands.
---Saying gnome 3 is better than windows 8 not so much a compliment as it is damning with light praise.
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.
Linus seems to be forgetting about the massive shift in software development that has occured, to consuming software as container-based microservices, and providing it as the same.
No one cares what architecture Redis is running on, as long as the service provides the same API contract and can be consumed by existing code. X86, ARM, Power, no one cares - run it where it performs the best at the lowest cost, thanks.
The same is true of all of the other microservices that you consume, and all of the microservices you provide that make up your software. As long as you can deliver the container targeted to that architecture, no one will care.
How does Linus think all those mobile apps get developed, since smartphones are 99.9% ARM? Well you develop on an x86 desktop, then deploy to ARM cell phones. Acting like developing on x86 desktops and deploying to ARM servers is some impossibility might be true at his level, the kernel level, but at the business process level you very rarely care. I'd say 99% of all bugs are due to some bad code or flawed design in something you wrote or a library you used. On the rare occasion that the system libraries of .NET, Java, Swift etc. or your database have a bug it's likely to be an implementation bug that affects all platforms. And in those exceptionally few cases where it's not you do a have a test/qa VM you can debug on.
Live today, because you never know what tomorrow brings
The power argument isn't really super true anymore-- Atom got pretty good, etc. But ARM already had a foothold, and... perhaps most important, it's not too onerous to be an ARM licensee. So there's a lot of SOCs now featuring ARM and with a superior degree of integration and nice things to design a phone with.
And then the same network effects hold true-- if 99% of users are Android-on-ARM then if you use Android-on-X86 you're going to have weird experiences at time.
1. Parts. People like mow cost, fast, low power and heat parts. That work better. RAM, storage, networking all has to be ready, working and fully supported. ... better than anything.
2. Software. The CPU has to support something great to make people change everything and learn to code a new system.
3. Cost. Power savings while doing more math and networking and
4. Ability of staff. People have to learn to code something new. Thats a lot of code to bring over.
5. What is the advantage when power costs are low, heat is easy to move, people know how to code on existing systems.
That new CPU and surrounding support has to be so much better at everything over a generation than anything on the market.
Domestic spying is now "Benign Information Gathering"
As a hardware and software developer for over 25yrs, I have considered ARM many times and always run into the same problem. As much as we like to talk about multi-threading, there are still many applications where the single-thread performance is the most important. ARM performance is just barely good enough for mobile devices and very limited Android TV boxes. The performance of ARM is catching up though. Maybe in a 2-3 generations the performance will be good enough for people to tolerate ARM laptops and desktops.
The "small cheap box" for ARM hardware means different things to different audiences.
Back in the 80's, the IBM PC was the definition of a small cheap box albeit it cost around 5,000$CAN. Enough to run some apps for work and some games for the kids. Then IBM PC Clones/Compatibles came along and started to redefine what small and what cheap meant. We could get decent capabillity equivalent to the what IBM was currently selling but at a fraction of the cost if we were willing to take a risk on lesser known brand names. GATEWAY, DELL, and the every other PC Compatible reseller were easily able to sell their kit since everybody out there had no computer whatsoever at home and thought they could use one, but didn't know what exactly to get yet. $UCKER was written on everyone's forehead back then.
Now everybody's a bit wiser and have a bunch of different pc's laptops and crazy reseller/support stories under our belts. We don't buy quite as often and try to make them last as long as possible.
So with all that in mind, when we buy something, we buy with the intent that it will last and not just for two years which is what the resellers sweet spot is.
I bought a few "small cheap ARM boards"...rock64, odroid-c2, zoomtak u-plus....4GB RAM or 2GB RAM in them. The speed of them is respectable. The RAM capacity does not compare with intel-based low-end gaming pc's. The storage capacity for arm boards also suffer and does not compare well in the general sense. Can I easily plunk in an m.2, sata into one of these arm boards? No I can't because all the varieties of all these different arm boards are so ALL-OVER-THE-PLACE in terms of offerings that they don't consistently offer the same kind of storage in all these devices and you can't expect anything easy when you shop around for "small cheap arm box" because they don't compare well to "small cheap intel gaming box" which better defines the "small cheap box" since it easily handles the load for SOHO and you teenager gaming requirements.
In other words, Linux is right. ARM won't win in the server space because it needs to conquer or at least compete in the work at home space first before it can have an opportunity to work as a server on-site or in the clouds for that matter. Working at home for me means 32GB RAM with 8+ cores CPU and GPU with newer sata/m.2 storage options like ssd/nvme and fiber included. No arm board at present provides that at a decent price. I'm not looking for a 25$ to a 50$ system. I'm looking more for the average $1000 to 2000$ GAMING desktop that could also be a SOHO office. ARM manufacturers don't have standards to make such a thing happen. most motherboards for pc's can handle most of that with the default price except for fiber capability. The ARM-based MACCHIATOBIN board is darn close, but it needed a default GPU to come with it to make it more general purpose rather than just for networking, but did it conform to the new server boot standard ? How come it can just handle 16GB RAM when any supermicro intel-based server motherboard can have 512GB to 1TB RAM installed on them?? The price points for these are awesome by the way. I have yet to see comparable ARM capability without sacrificing something or paying 6-10 times the price.
Having a new server boot standard for ARM is good, but we need similar standards for smaller boards also. We shouldn't be arguing about graphics drivers for linux at this point. They should come included for every distro be it ARM or intel or riscv without any discussion that it will crap out in production. Works at home means works on the servers....ARM-based SOHOs small cheap boxes and servers need decent GPU capability right from the start and not as extra option you have to pay for...It should be included as it usually is when you buy a PC desktop system.
Long before they were gobbled up by Oracle, Sun used to offer universities cheap sun workstations. They had a trade in program where you could get half off on your upgraded computer by turning in any old sun server. They never asked for the computer back but the same department couldn't use the machine for two upgrades which encouraged it to be recycled into a different department who could then upgrade it to something else. University discount was typically 50% and sometimes 65% and the trade in dropped the cost by an additional half so some departments were buying new hardware at 17% of what a small company would pay. A $10k Sun server at $1,700 was a much more powerful than a pc of the day. When those admins hit the corporate world in the dot.com bubble, they knew Sun hardware and they bought massive amounts of it.
Google, Amazon and Oracle all control their own server architectures, each use a different processor architecture and none of them care what Torvalds thinks. These companies have a great deal to say about what the cloud is and they don't agree on processor.
The processor that runs code deployed in a high level language really does not matter, does Linus really not understand that?
The reasons x86 grew to dominate have little to do with current requirements and aren't interesting in predicting the future.
The server market is actually different now... DCS is bigger than home servers...
arm has this now :
https://github.com/ARM-software/sbsa-acs
but well thought out just dated Linus Torvalds...
John Jones
EOM
We suffer more in our imagination than in reality. - Seneca
Linus has just "proved" that Linux can never supplant Windows in the server space.
Which IMHO shows his argument is flawed - a rare occurrence.
On the one hand, he has a point, developer-friendly form factors are x86 and that's unlikely to change due to the propensity for developers to have some x86 app they want and better to hedge your bets.
However, the presumption that cloud providers would prefer x86 because it can carry a price premium fails to acknowledge that the providers can potentially get wider margins out of an ARM ecosystem. In x86, you have two vendors and thus they only get so desperate to compete against one another. In ARM server space, at one point you had Marvell, Qualcomm, Broadcom, AMD, Cavium and more vying for the space. The big providers love pitting many vendors against each other as generally *someone* is desperate enough to take a big loss just to get the business. This probability decreases as you have fewer viable vendors.
But it's also been a bit rough. Most of those ARM vendors have since given up their server ambitions. Of the ones that made it to market, none of them could deliver the performance or even performance/watt near the x86 offerings. Many of the advantages they have enjoyed in mobile space (notably better idle behavior) erode in a server setup with high utilization.
XML is like violence. If it doesn't solve the problem, use more.
The leaks nowadays are near zero. Nearly all microservice delivered applications are written in NodeJS, Go, or Python. None of these languages care what architecture you're running on, and as a developer no one is writing architecture-specific code.
Even if you're doing high performance machine learning, the libraries you're using are likely Python based, and hide away the iron and GPU types from you to a very large level.
The point is that Intel architecture downscaling is stopping. The only reason why Intel compatible architecture has the lead is because they can run their less efficient computing architecture on smaller silicon. And that's slowing down due to physical limitations. It doesn't seem that they are capable of tackling this problem.
Once the playing field is 'even' and both ARM and Intel architecture are running on the same nano-scale, it's the most efficient platform which wins eventually. Obviously consumer habits and marketing materials will slow down this effect, but given some time, I wouldn't rule out the ARM architecture on servers just yet.
It all depends,... but ARM isn't in a bad position if physics block further downscaling of the silicon.
You make a good point about the durability of detachables. As for RAM use:
Or what fundamental thing about computing has changed since then, other than the increasing aggressiveness of web analytics and adtech to eat RAM while continuously tracking viewers' browsing?
That's not enough?
Correct, it's not enough. The user can work around "the increasing aggressiveness of web analytics and adtech to eat RAM" by using a tracking blocker. This can be the built-in tracking protection feature of the Firefox web browser or the Disconnect extension for Google Chrome. Though the user will see fewer ads with a tracking blocker, it isn't really an ad blocker, as a tracking blocker allows publisher-hosted ads and any other script that isn't involved in cross-site surveillance of viewers' browsing history.
To save money, I tend to use laptop computers until replacement battery packs are no longer readily available. Thus I was able to keep my daily tasks (software development and web browsing) usably fast on a laptop with 1 GB of RAM until 2015 and 2 GB of RAM until 2018. Tracking blockers were a big part of what made this possible.