8 ms·
Which pre-RISC simple CPUs are you thinking about? I think the key design features of RISC are no microcode, pipelined execution, usually one instruction per c
by kragen 4y ago
Which pre-RISC simple CPUs are you thinking about? I think the key design features of RISC are no microcode, pipelined execution, usually one instruction per clock, a load/store architecture (no memory operands to ALU instructions), fixed-length instructions, and a large orthogonal general-purpose register set to compensate for the lack of memory operands.
Maybe the CDC 6600 sort of fits, but it only had 8 60-bit operand registers, and they weren't orthogonal; you could load into 6 of them and store from 2 of them, and you couldn't use them for addressing (addressing was done with 16 other 18-bit registers). It was only barely pipelined, though it was sort of superscalar. I do think it fulfills the "no microcode", "fixed-length instructions", and "usually one instruction per clock" desiderata — but you can hardly say it was a "simple CPU", its design objective being to build "the largest computer in the world", and sporting 60-bit registers, hardware floating point (single and double precision), and a heavily multibanked memory system.
- Taniwha 4y agoI'd include the PDP-8 and successors/cloners like the DG NOVA
- kragen 4y agoThe PDP-8 is certainly simple, but it has microcode, doesn't have pipelined execution, never approaches one instruction per clock, has memory operands to virtually every instruction (including an indirection bit, a mortal sin in RISC), and has a tiny register set. You could say its zero page is like a "large orthogonal general-purpose register set" but ⓐ all your ALU instructions have to involve a register which isn't in that set (the single accumulator) and ⓑ the current PC page is is just as accessible as the zero page. All it has in common with RISC is the fixed-width instruction set and a (very) small number of instruction formats. So I would say the PDP-8 is the opposite extreme from RISC. If you like the PDP-8 you should check out the 32-bit version: https://github.com/johnwcowan/pdp8x https://github.com/johnwcowan/pdp8x The NOVA is maybe a little more plausible, since it at least has a load-store architecture and four accumulators instead of one, but it still doesn't feel very RISCy to me. I mean it's maybe less RISCy than the 80386?
- kragen 4y agoCorrection: although the PDP-8 has "microcoded" instructions, the "microcode" is actually in the instruction. There isn't a microcode store that runs a little program to implement each instruction, as there is on, for example, the 6502.
- Taniwha 4y agoyeah you see I think that's the riscy-ish thing of it all, and why I nominated it: having bits in the instructions wired directly to gates in the ALU without any decode is RISC at its essence
- brucehoult 4y agoIn some ways. Maybe it's more like a short VLIW :-) Either way, it's not conducive to having an Instruction Set Architecture with varying implementations.
- TMWNN 4y ago>Which pre-RISC simple CPUs are you thinking about? Would 6502 qualify? I know that the ARM team moved away from it to design its own actual RISC architecture, but I've often heard it as being very RISC-like.
- kragen 4y agoI think the 6502 is a lot more like the PDP-8, except that it has variable-length instructions (interspersed opcode bytes and operands). Looking at my list above of RISC features: - fixed-length instructions: no - no microcode: the 6502's PLA amounts to fairly extensive microcode - usually one instruction per clock: the 6502 doesn't come close to this, in part because of its microcoded execution approach. http://www.6502.org/tutorials/6502opcodes.html http://www.6502.org/tutorials/6502opcodes.html shows that different instructions take from 2 to 7 cycles, depending on the addressing mode. - a load/store architecture (no memory operands to ALU instructions): because the 6502 has only one accumulator all its ALU instructions have memory operands, and generally several different addressing modes are available. - pipelined execution: no. - a large orthogonal general-purpose register set: no, although you can use the zero page as a register file (as on the PDP-8) you can't use data on it for addressing (unlike the PDP-8!) or ALU operations with anything except the A register. So I think the 6502 is in every way at an opposite extreme from RISC. Which is not to say it's overcomplicated — it's an amazingly simple processor, actually, almost an order of magnitude smaller than the ARM 1 or any other RISC processor, roughly on par with the much more limited PDP/8 — but that the design tradeoffs it embodies are very different from RISC. They're not particularly similar to the systems the IBM 801 was designed in reaction to, either, except I guess that the 6502, like the IBM 360 and 370, is byte-addressed and supports both decimal and binary arithmetic; and the low-end S/360 Models 30 and 40 used an 8-bit ALU, like the 6502, but they hid it from the user: https://www.righto.com/2022/01/ibm360model50.html https://www.righto.com/2022/01/ibm360model50.html
- brucehoult 4y agoI agree with you. The 6502 isn't anything at all like RISC, it's "we can only just barely make a computer at all with the number of transistors we have available". The 6502 uses a similar number of transistors as the 6800 (different company, but largely the same designers) but is MUCH faster in actual practice. The 6800 is a lot simpler and more orthogonal, the 6502 is a lot trickier and more efficient. What the ARM designers liked about the 6502 was that it read or wrote a byte from memory on every clock cycle, and you could quite accurately calculate the execution time of a 6502 program just by counting the number of bytes of instructions and data read and written (and for each instruction applied min(bytes, 2)). They are on record as saying they tried to duplicate this in a 32 bit CPU. Making maximum use of memory cycles without a cache was also the reason for ARM's load/store multiple instruction, so that a single 32 bit opcode could then drive up to 16 words of data read/write before needing to fetch another instruction. This feature became redundant (as least as far as speed went) once instruction caches were introduced, but ARMv7 CPUs are mostly running without caches to this day. ARMv8-A removed load/store multiple.
- adrian_b 4y agoAs you say, CDC 6600 and its successor CDC 7600 have many of the characteristics of the RISC CPUs. Compared with the IBM System/360, which was introduced around the same time, the instruction set of CDC 6600 was very simple. Having hardware floating-point is something that is orthogonal with being RISC. The goal of the RISC methodology of designing CPUs was not to create crippled CPUs that are so slow as to be unusable for practical purposes. The goal was to create a higher performance CPU by removing some features with great cost and little benefit. Hardware floating-point is not one of those features. Removing the hardware floating-point unit from a CPU cannot increase its performance, it just makes the CPU useless for floating-point applications, because the speed of software FP implementations is much too slow. The first RISC and MIPS projects did not have a FPU because they were student projects and designing a FPU would have required too much work. When commercial CPUs have been derived from those projects, they had to add hardware FPUs to become viable for the workstation market. Also the width of the registers is something orthogonal with being RISC. The same can be said about the partition of the registers into a set of address registers and a set of data registers. Depending on the ISA, such a partition can result in a simpler hardware than for a unified set of registers, e.g. by allowing the use of less read-write ports on the registers. Simpler hardware is a RISC goal. There have been a large number of early computers with no microcode and with fixed-length instructions. Many have also been pipelined in various degrees. However no early computer had a large number of registers, because the registers were very expensive when made with discrete components, so only a few computers had 8 registers or at most 16, but the majority had less registers than that. With only a few registers, having only register-register operations and load/store operations would have been inconvenient, so I do not remember any early computer where most of the computation was done with register-register operations, before CDC 6600. The splitting of the load from the operation that uses its value, either as distinctly encoded instructions or as micro-operations, has become necessary only when the CPU became faster than the main memory, like in CDC 6600, or in monolithic CPUs after 1980. In the slower CPUs, this would not have been a simplification. A more precise formulation of the purpose of the large register set is not "to compensate for the lack of memory operands", but to allow the fast execution of the instructions despite the high latency of the loads from memory, by splitting the register-memory operations into register-register operations and separate loads. This split has the added bonus of enabling more efficient instruction encodings within the constraints of a fixed-length instruction format. So a part of the RISC characteristics were present in the early computers, but having a large number of registers and doing computations only with register-register operations are choices that lead to a simpler CPU only in a certain technological context, which became available for cheap computers only around 1980, when the initial RISC projects were launched.