You should watch this video: https://www.youtube.com/watch?v=Ii_pEXKKYUg
The most important information therein is that the difference in code density is minuscule between x86, ARM and RISC-V. The differences between GCC versions is even bigger.
> The equations that you have to resolve to issue an X86 instruction are simply more complex than for ARM, and all that bit-flipping consumes power.
It's actually just 3-10% of power consumption [1] and I even heard it claimed that the instruction decoding on ARM is larger than x86
[1] https://www.usenix.org/system/files/conference/cooldc16/cool...
ARMv7 OK, is-it still true with ARMv8? It seems to be a much more 'reduced' ISA.
Admittedly some of AArch64 is much cleaner, it involves fewer new conditional instructions than you would expect for an ARM architecture; however it sure as hell ain't RISC.
There's no reason to believe this to be an immutable law going forward for much longer. With more and more going into the browser & cloud, how much is really left on the client side to be backwards compatable with these days?
The first thing I do when I reformat is install chrome, login, and sync my Google Account. I have all my important documents on Google Drive, a full office suite in Google Docs, all my bookmarks, account logins, etc.
Personally for me the web is HTML + CSS, for everything else there is a native application, even though I have done my share of web application projects.
I also don't put my private data in the hands of strangers.
Also do know lots of people that think like I do.
For desktops/laptops and mobile phones, this may be true. For embedded device (where a lot of ARM chips end up) it is not an option, usually.
Likewise, on Windows, there is a huge amount of third-party software that is, for better or worse, tied to the CPU architecture. And for a fair amount of that software, vendors are either unwilling to port it to a new CPU or have stopped supporting the software altogether (or have gone out of business). Consider the sad fate of Windows RT. Windows on low-end ARM devices might have been sweet (as far as Windows goes), but if the only piece of software it runs is IE/Edge and Office, it is not terribly useful.
No, RISC was a response to CPUs becoming faster relative to memory access. Smaller decode logic meant more die space for registers and cache.
ARM conditional execution is very clever.
also mostly dead in 64bit armv8
[1] interestingly, POWER8 is capable of converting unpredictable conditional jumps over a small number of instructions to conditional execution.
If you ever have a question about computer architecture, ask two questions: 1) where does the memory bandwidth go, and 2) where does the die area go. All else follows from this.
RISC only made sense when CPU clock speeds were at rough parity with central memory speed, on-chip I-caches were limited, pipelines were short, and compilers were only good at modest optimizations.
If you look at functionality per instruction byte, RISC is fairly low. In today's world, CPU clocks are hugely faster than memory speeds, on-chip I-Caches are huge, pipelines are very very deep, branch prediction hardware is very good, and compiler back-ends are much much smarter than the peak days of RISC. CISC wins because the amount of functionality that you can move into the I-Cache per clock is higher and the amount of functionality you can keep in a given amount of I-Cache die area is higher, and compilers are good enough to target specialized instructions efficiently.
Is what Intel has crammed into X86 impressive? Yes, very. And it was damn hard work. I can tell you that walking all the way out to byte 15 of an instruction to look at the MOD R/M byte to decide if you have to raise an illegal instruction exception is a painful long path to squeeze under the clock constraint. But breaking backwards compatibility is just not something customers will put up with. So logic and circuit designers get to ply their trade in it's most convoluted form with the X86.
Perhaps these days I should amend my question list and add a third: 3) where does the power go? This is where ARM has an advantage over X86. The equations that you have to resolve to issue an X86 instruction are simply more complex than for ARM, and all that bit-flipping consumes power.