HEY Cred Forums, ehat do you think of CISC vs RISC?

Yes. Intel as of the past 15 years uses RISC internally with a CISC decoder. It's cheaper to do that than have the whole desktop market to switch away from x86/64.

CISC and RISC are both antiquated terms

all hail PISC masterrace

it's an ancient philosophical war that died over a decade ago, modern "RISC" chips are no more "simple" or "reduced" than a typical CISC design, only really differing in the way instructions access memory and maybe design decisions that don't really matter anymore like register counts (even a gimped ARM microcontroller chip nowadays has more instructions than classically "complex" chips like the Z80 and M68k)

it feels like the majority of people here who still propagate CISC vs. RISC are idealistic bikeshedders who only know how to jerk off to ancient benchmarks and anecdotes without even the slightest hint of understanding context or even the designs themselves

x86 isn't really "RISC" where it matters, just RISC-like in the way it executes its still very CISC-like instruction set

RISC looks nicer, more organized, and all the instructions look like they all execute in the same amount of time.

This helps supplement my autism. I hope RISC wins!

This.
Also it's way nicer to make a virtual machine for + it's more efficient to decode and execute.

x86 jits cisc to risc microcode. this dramatically increases the burden and weakens the capabilities of software implementors, but affords great flexibility and power to hardware implementors to do novel shit internally without changing how the hardware is used. it also makes it a lot harder for competitors to implement compatible chips

the debate between CISC and RISC is not really about performance any more so much as flexibility. the goal of RISC-V is not to outperform x86; rather, it's to enable modular custom hardware supporting limited subsets of instructions, and potentially exotic instructions. the RISC guys are banking on a future where stuff like FPGAs is the norm

It already has. x86 CPUs have been RISC internally since the 90s.

Yes

But that's wrong, dumbass.

x86 CPUs are RISC processors that accept a CISC instruction set and convert them to RISC before executing the instructions.

There are still CISC CPUs, for example 68k and Z80

the entire point of microcode is that it's not a stable interface. a huge chunk of the motivation for RISC is to have a simple interface of composabe modules to 1. migrate work into the software compiler, and 2. enable competition in the on-demand fabricated hardware market. so microcoded architectures are missing many of the features one would expect from RISC architectures, which is why RISC-V exists

RISC architecture is going to change everything.

I'm not saying x86 is the best because it's RISC now by any means, I'm just saying that even the predominant CISC architecture actually uses RISC.

>x86 CPUs are RISC processors that accept a CISC instruction set
that's kind of a senseless statement, the usage of micro-ops in x86 chips doesn't make the instructions themselves any less "CISC" the same way the Alpha didn't stop being RISC when they implemented more CISC-isms like out-of-order execution

x86 is wed to the PC and will remain so for the foreseeable future. Many have tried to change this. All have failed. Repeatedly.

>pain
Agreed. Had 68k won the world would have been a better place. No segmentation for a start. Better code too.

Intel claims so. Occasionally. Further down it is microcode. It is all a mess.

>It's cheaper to do that than have the whole desktop market to switch away from x86/64.
Therein lies the problem. It was AMD that did a flag day. Intel should have taken it a lot further. Tons of disused instructions waste valuable code space leading to pre.pre-prefixes all the way down.

>RISC internally
Sure. Problem is that programmers are exposed to the toxic CISC ISA that is a pain. CICS does not have to be toxic, 68K was a lot better.

The only truly libre RISC architecture still in the running is MIPS and thats only barely, couple routers here and there. Lemote is dead. Everything else has ARM blobs or other microcode blobs everywhere.

That's just on the processor, not including all the other backdoors and blobs holding phones & SoCs back etc.

wait a minute, am I misreading this post or are you trying to imply that 68k isn't CISC? or are you just saying it's a better CISC? which I would probably agree with I guess.

68k is very much a CISC. It is just a whole lot better than x86. i spent many years as an assembly programmers on embedded stuff. 6502, 6809, 68k, DSP56x00 etc were nice. Zilog and Intel were gruesome.

I've been meaning to learn ASM for a simpler arch, I thought Z80 was one of the better ones to go for. Should I just learn 6502 or 68k?

heard great stuff about 68k assembly but never looked at it personally (hence the "I guess")

kind of want to mess with it but it feels like it wouldn't have as much utility since I'm not into embedded systems

Nah, it's not philosophical. It about what way round you read the bits you fucking sperg.

Fuck off.

Z80 was once popular due to CP/M but 6502 has had a far more lasting power. Amazingly more than 100 million units are made on license every year, embedded in everything from key fobs to picture frames to high reliability stuff like pace makers where life time guarantee takes on a new meaning.

It is a pleasant processor to program and the 6502.org is a good source for resources and has an equally pleasant forum.

6502 teaches you frugal programming and the first spreadsheet was made in 48 KB (yes, kilo byte) on a 1 MHz Apple II running a 6502.

68k gives you more room to play with including MMU so you can run Linux and uLinux.

The embedded world is alive and well and is less prone to outsourcing. I no longer do embedded work but the background knowledge has been useful also in other settings.

For example, Windows RT devices are required to have Secure Boot enabled by default, preventing you from replacing the OS.
There's silly things on other ARM platforms too, for example, Android drivers pretty much need to be compiled into the kernel, resulting in a separate incompatible kernel for every device.

not to mention the GPL violations.

you're a whiny one aren't you
go back to jacking it to 20 year old SPECfp results like they ever meant a shit

That's endianness, dumbass.

x86 needs to FUCKING DIE!

you need to fucking die, ARMjeet

>not liking x86 means you like ARM
Fuck off, retard.

I'm more interested in POWER, ARM doesn't scale up well.

Dat Talos POWER8 tho. Too bad I'm a poorfag.