What killed RISC?

this

RISC-V is open. RISC in general isn't

what the hell? this ancient human boomer technology?

Well RISC isn't an architecture unto itself, it's like a paradigm of design for architectures.. or some shit.

nothing killed it, you computer illiterate.

Intel/Windows > Risc/Un*x

It's what you had at college in the 90s.

Attached: 62FF8FC9-C9A2-442B-AD39-217F6C217AE9.png (500x522, 21K)

>Intlel+Windows
sure thing dipshit

Attached: aaaaaa.png (863x593, 189K)

if RISCV somehow got popular on the desktop, would coreboot be possible on it?

im looking for a ARM cortex 76 64 bit processor any one knows where can i find it without buying as a company

Fuck no. It has even worse problems than ARM in that regard.

Nothing, you stupid meme poster. It's alive today in ARM and RISC-V.

>ARM is everywhere

litterly bloat

Calm down, Cait.

Yes. Coreboot would probably be the go-to BIOS for RISC-V, ideally.
Retard

CISC became more orthogonal (at least for new instructions).
Meanwhile many RISC architectures added thousands of instructions.
But mainly it was PCs having a huge market. Much like phones today.

It was shit.

Within 5 years I'm sure we'll see a 100% open RISC-V SBC which is reasonably capable of running a desktop OS.

Nothing, it's everywhere now, CISC died in the 90's. Just because your binaries are compiled with CISC instructions, doesn't mean the CPU in it's core isn't working like a RISC one, there are no widespread CISC CPUs in use anymore.

Attached: 1547518672178.gif (230x230, 1.54M)

RISC was fun but CISC has always been more open. As much as people shit on x86 I can build a PC with an Intel CPU or AMD CPU using parts from a ton of manufacturers, and aside from the CPU and the motherboard having to match, they all generally work together.

RISC is generally very open. There's OpenPOWER and OpenSPARC, also OpenRISC and Amber (ARM), but not as feature rich as the first two.
You can get any of them and fab your own CPUs based on it or use them as FPGA softcores.

RISC-V is a joke next to any of these.

Attached: 1557264964884.png (300x308, 95K)

That has literally nothing to do with CISC vs RISC, and modern x86 CPUs are really a RISC core, which internally converts CISC instructions into RISC microcode.

You're very misinformed or confused user.

>RISC-V is a joke next to any of these.
finally someone said it, risc v is top soi to shill to retards too dumb to look into shit themselves

Except for the 9000/712 just about every machine in that picture cost a minimum $20,000 and by the early 2000s did very little you couldn't handle just as well or better on a $2,000 NT machine or proper server/supercomputer, while the former especially did so much more on top of it versus the very expensive SysV variants with highly specialized software bases those systems were almost always restricted to.

The early advantages of the RISC philosophy (simple design, register spam and lightning fast clock speeds) quickly turned to disadvantages, became meaningless or simply evaporated altogether in desktop systems and use cases, all while CISC designs' disadvantages were further minimized by novel design choices and improving production process, and the RISC/UNIX juggernauts faltered and struggled to keep them competitive. The Itanium effect mentioned only really affected to SGI (but who knows if MIPS V would have really been that good regardless) and perhaps Compaq that probably would have ended up shitcanning Alpha regardless. The similar difficulties faced by Sun and Apple/AIM on the desktop are testaments to that.

In short, RISC died on the desktop because it was pointless there by the end. It did offered nothing but fatter margins from vendor-locked customers who to this day are still scrambling to get away from those ecosystems.

By that argument nothing killed RISC, which I suppose I can accept because it's subjective.

I am not. Look at ARM, Macs in the past, the devices in OP's post. Systems that market themselves as RISC have historically been very locked down, aside from the new OpenRISC project which is obviously not widespread.

Because the idea of doing one instruction at a time, sequentially, and at a fixed clock rate is stupid and outdated. The better idea is to have a simple, fast, RISC-like core of instructions for general computation, as well as sets of slightly slower, but faster than combined RISC, CISC-like instruction sets for more specific and complex tasks, and then to tailor what actually gets put into silicon depending on the workload of the processor. Which is why phones, where power and heat have premiums, use relatively simple RISC-like architectures, and PCs, where performance is king, use a more CISC-like architecture. But both, at least now, are blended. ARM has extensions that are CISC-like, and modern x86 procs have RISC-like "cores."

>But mainly it was PCs having a huge market.
Yeah the thing that either killed classical RISCs (or at least put them in position to be killed) was that somewhere around the early-to-mid 90s cheap PC clones started getting fast enough to do many things that people previously had to plunk down big dollars for RISC servers and workstations to do. The massive size of the PC market meant that Intel could drown CISCs problems in supertankers full of R&D money and new fabs.

T-series SPARC designs are way too focused on a small set of use cases, none of which are anywhere close to your desk. If you laughed at AMD during the Bulldozer era, just wait until you see the how pathetic a T1 is for single-threaded applications, or really any kind of application that doesn't basically saturate it.

I don't think they ever fully opened up any of the proper workstation SPARC chips either like the UltraSPARC III/IV, but then again those were also getting quite long in the teeth by then as well.

Windows

>By that argument nothing killed RISC
Absolutely nothing killed RISC, it's still very much alive, just not in desktops.
>The massive size of the PC market meant that Intel could drown CISCs problems in supertankers full of R&D money and new fabs.
I see this repeated a lot but I don't really like it. Intel definitely did have a lot of money to throw at improving their designs, but to say that x86 pulling ahead was just a result of blindly throwing money at it until it surpassed supposedly "superior" technologies by sheer brute force is kind of silly. IBM, HP, Motorola, Sun and pretty much all of the rest of them that were absolutely rolling in cash especially at the maximum extent of the dot-com bubble also had lots of money to burn on R&D, and they did exactly that, and still ultimately abandoned their efforts.

Those companies also had to spread their R&D dollars among more business lines. Intel was pretty much just a chip-maker.

>modern x86 CPUs are really a RISC core, which internally converts CISC instructions into RISC microcode
Brainlet here, what is the advantage of this? It seems like it would be less efficient but I also hear that x86 outperforms ARM and other RISC architectures in most tasks.

Linux actually

it's freeware and works on x86/AMD64

why pay for SPARC, Power, or Alpha to run UNIX when you can run Linux for free on cheap x86/AMD64?

Modern CPUs are complicated as fuck. I only have an extremely surface-level understanding, but it allows reordering micro-instructions, giving potential for optimisations.

>freeware
gnu.org/philosophy/words-to-avoid.en.html#Freeware

You're not wrong, but they were also larger than Intel and had more than enough money to pour into those efforts nonetheless, and none of it matters in the end because designing a good product isn't just a matter of throwing money at it. See the Itanium fiasco, or even better yet, see the success AMD64, the thing that actually put the final nail in the coffin for desktop RISC.

>I am not. Look at ARM, Macs in the past, the devices in OP's post. Systems that market themselves as RISC have historically been very locked down, aside from the new OpenRISC project which is obviously not widespread.
The IBM PC compatible is an anomaly. Companies have cloned everything from C64s to Macs and they've got sued for their trouble. The same way Compaq were butt fucked by IBM. But the difference is that Compaq fought tooth and nail and against all odds WON that fight.

And let's not rose-tinted specs the past. The clones were full of problems, but because everyone bought clones, software was written to bodge around the fact that most of the IBM spec was not "safe" and to stick to pure software as much as possible.
If you built a PC in early 199x you had the choice of an Intel chipset mobo or SIS, or Via or various others. And unless you bought the Intel, you WERE going to get compatibility issues.
Today Intel and AMD *aggressively* control the motherboards. You can buy a mobo from Asus, Gigabyte or MSI but the bits that matter are all the same parts. GPUs are just the same chips repackaged.

In the past, "open" simply meant did they publish specs so I could program it and make add-in cards that would run without being "blessed" by a central authority. And old-risc hardware definitely did that. Modern ARM with its signed, locked bootloaders is the enemy, but if you want the PC without x86, that might be more than anyone can achieve ever again.

Your posts have nothing to do with RISC or CISC. There literally are no true CISC CPUs anymore, it's all RISC.
Just because OP says something, doesn't mean it's true.

One of the major hurdles with RISC was that the simpler, more efficient design of the instruction set meant that while you saved a tonne on CPU silicon, your RISC programs were significantly bigger than the CISC versions because every instruction was 4 or 8 bytes, things which were a single 2 byte instruction on x86 were 3 or 4 32bit instructions on RISC, etc. And this was a problem because it meant more RAM bandwidth was needed to feed the CPU, more cache was filled with these bigger programs, and general stuff like that.
So Intel's approach to convert CISC to RISC actually fixes a big problem. It reduces the program size, makes better use of RAM and cache size and throughput AND because it has more context to what you're doing, the optimiser can make better choices.
That's why there's actually been more of a shift AWAY from RISC in a way. Vector instructions are quite un-RISC but even ARM has them. And that's why Intel doesn't deprecate x86 in favour of exposing their internal RISC ISA. Because as long as you can keep people paying for the extra silicon, it actually makes better CPUs.

Other CISC designs exist beyond Intel and AMD's own peculiar x86 implementations, which are not RISC, and certainly nowhere near "true" RISC even if they use some of its better ideas internally.

>And that's why Intel doesn't deprecate x86 in favour of
Intel tried to deprecate x86 several times and couldn't - see above with Itanic. The x86 external interface has to be there whether Intel likes it or not.

Interesting. Thanks for the explanation user.

>can't follow a simple post chain
No, there are no "widespread" CISC CPUs.

When you take the predecoder away, it's literally a true RISC CPU, down to the main decoder.
Just because it has a predecoder that does x86 to a simplified set, doesn't mean it has a decoder that does 4000 instructions.

were these all computer science oriented workstations, or maybe financial computers? cad workstations from before x86 & autocad?

Sure, when you take out the complex multi-cycle instruction set, and the specialized execution units, and the out-of-order execution, and the microcode, and all of the other very un-RISC like things, eventually you'll indeed get a very simple, and utterly useless CPU.

All of that, and the steadily receding goalposts aside, in the end there is no RISC or CISC anymore. The two annihilated each other in an orgy of pragmatism decades ago, and quite honestly you could make a slightly better, but still quite limp argument for the opposite case. Most modern "RISC" architectures are monstrosities.that adhere to very few of the original core values behind early RISC designs.

All of the above, and more.

>What killed RISC?
Apple ditched RISC because IBM's roadmap for the G5 (IBM PowerPC 970) didn't extend to, and past, 3GHZ.

No throwbacks to the hackers movie yet?

x64's Instruction Decoder to compile CISC into RISC micro-ops

Marketing bullshit by everyone else.

>see above with Itanic
The Itanium was piece of garbage from the very start. It was a dumb chip that relied on a magic optimizing compiler that never showed up. The only people able to make decent VLIW chips and the compilers to use them are he Russians and their Elbrus architecture.

Attached: 1378092255026.png (600x269, 61K)

Marketing bullshit pretty much summed up RISC on the desktop.

>doesn't even know what RISC is

You do realize ARM exists? Both of your points are disproven by ARM.

I'm not really sure how ARM existing suddenly makes x86 a RISC ISA, or what other point it's even refuting. You kind of sound like you're just blurting out buzzphrases for the sake of arguing with someone at this point.

>There's OpenPOWER and OpenSPARC, also OpenRISC and Amber (ARM)
Yet no-one ever posts CPU schematics for these, while RISC-V ones are going to be available this year.
Please post schematic PDFs next time you claim OpenPOWER is open.

This is a good post.

IBM will license the POWER9 RTL to you which is more than can be said for anything in the x86 world. Not that it even matters if you don't have $1bn to spend getting the chip fabricated at a 14nm plant.
At least on OpenPOWER the firmware is completely open, too.
This wasn't even true for SiFive's "high-end" RISC-V offerings until very recently.
Not to mention POWER9 blows everything else
with open firmware out of the water in terms of raw performance.

Capitalism. x86 was $0.000001 cheaper to build.

>SiFive
SiFive is indeed unfortunate. I'm hoping lowRISC gains traction.
lowrisc.org/

Retard commie

Killed RISC? ARM chips are the most-sold processors in the world.