3 ms·
As 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 aroun
by adrian_b 4y ago
As 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.
- kragen 4y ago> Having hardware floating-point is something that is orthogonal with being RISC. ... Also the width of the registers is something orthogonal with being RISC. Agreed, but it's not orthogonal with being simple. You said, "Before IBM 801, there have been many simple CPUs,...they would have been called RISC". My reason for bringing up those points about the 6600 was to show that, however RISCy it may have been, it was anything but simple. So which machines did you mean if not the 6600? (I don't think that it was very RISCy, given the non-orthogonality of its register set. You are probably right that its non-orthogonal register file simplified its implementation significantly, but it's a distinctly non-RISC feature. But whether such a complex machine, perhaps the most complex in the world at the time and certainly the fastest, was RISCy or not, has no bearing on whether there were simple CPUs that would have been called RISC.) I don't think it's accurate to say that the early RISC projects (the 801, the MIPS, and the RISC) had a large register set to allow the fast execution of the instructions despite the high latency of the loads from memory, although it was true of the 6600. Rather, as I understand it, it was to speed up the instruction decoding, permit pipelining, and reduce the required bandwidth of the loads from memory. Zero-wait-state memory was still a thing in workstations up to the 90s; there was no latency of loads from memory. Now you seem to be saying that you don't think there were any pre-801 load-store architectures except the 6600. That sounds dangerously close to the assertion that there weren't any pre-801 RISCs. But, as I understood it, your thesis that I was debating was that there were not just one but many pre-801 RISCs, and that moreover they were simple, but that they weren't called "RISC" because the term hadn't been invented. Did I misunderstand? Did you change your mind? If not, what were these simple pre-801 RISCs, and what RISC characteristics did they have?
- adrian_b 4y agoLike I have said, except for the CDC 6600 and its successors, including Cray-1, which used register-register operations, I have meant that many early computers had a subset of the RISC features enumerated by you, i.e. fixed-length instructions, no microcode, and in some cases also pipelining (which before IBM Stretch introduced this word in 1959 was called overlapped execution). They also had simple addressing modes and a relatively small number of instructions. Most of these characteristics were present in the first electronic computers made with vacuum tubes. In time, the computers became more complex, so after about 15 years of evolution computers like the various IBM System/360 models had features like microcoded implementation, variable-length instruction encoding, register-memory operations, addressing modes with 3 components, many complex instructions for special purposes that were seldom used. All these features, which became standard around 1965, have been removed 10 years later in IBM 801, in order to enable a higher performance, by reverting a part of the evolution from the first 15 years of the electronic computers.