4 ms·
> Having hardware floating-point is something that is orthogonal with being RISC. ... Also the width of the registers is something orthogonal with being RISC.
by 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.
- kragen 4y agoCan you name one? You've named Stretch but presumably you're not trying to say Stretch was a RISC; and the Cray-1 was developed after the 801 and isn't much RISCier than the 6600, and even less simple. I admit I'm not very familiar with first- and second-generation CPU architectures, but the ones I have read about in any detail, like the LGP-30, the TX-0, and the IBM 1620, are very far from RISC.
- adrian_b 4y agoI am too lazy to search right now through the library, but there are plenty of books about the history of electronic computers, which describe some of the vacuum-tube computers of the fifties which introduced various innovations, e.g. the computers built by NBS (SEAC & SWAC), various IAS derivatives, the IBM scientific computing series starting with IBM 701, and many others. For some of the early computers there are manuals at bitsavers.org. All the early computers had by necessity features with low implementation cost, i.e. hardwired control, fixed-size instructions, simple addressing modes, low number of instructions, etc. The RISC CPUs returned to this simplicity, but they did not become completely similar with the early computers because the early computers did not have a large set of registers allowing the computations to be done by register-register operations. The early computers did not have many registers for 2 reasons, first they would have been too expensive when made with discrete components, and second there was no need for them because the memory access was fast in comparison with the instruction execution time. Nevertheless, the concept of an ISA separated in register-register computational instructions and load/store instructions for accessing the memory has also not been newly introduced by the RISC projects, but it dates back to the CDC 6600, in 1964, even if at that time having only 8 data registers was the reasonable register set size. So all the RISC recommendations had been used, for various reasons, in earlier computers. What was new with RISC, and this has appeared for the first time in the IBM 801 documentation, i.e. in 1975/1976, was the idea that by returning to the original simplicity of the older computers less hardware resources are needed to implement the CPU, and then the saved hardware resources can be used to implement other features that have a higher impact on performance, e.g. a larger register set, on-chip cache memory, faster parallel multipliers, and so on. The RISC approach was a more rational CPU design optimization methodology, which advocated the measurement of the complete performance impact of any new feature, e.g. an extra instruction or addressing mode added to the ISA, and the rejection of the features which add too much cost while providing too little performance increase or even a performance decrease, because the added feature might accelerate a seldom used application, while slowing down all the frequently used applications. The optimization approach proposed by RISC remains as correct today as in 1975 or 1980, but when different manufacturing technologies are available the optimum CPU design can be very different. While including certain instructions in the ISA might have been a bad choice in 1980, e.g. an extra instruction for computing the tensor product of 2 vectors, a performance vs. cost analysis done in 2020 might conclude that it is in fact the best change that could be done to an ISA in the given technology, in order to provide maximum additional performance at minimum additional cost. So what must be retained from RISC is not e.g. the necessity of having a fixed-length instruction encoding, or any other feature that was optimal in 1980, and which might happen to be still optimal in 2022, but this is not certain and it must be demonstrated by a new analysis, based on the current technological capabilities. What must be retained from RISC is that CPU design is an optimization problem and any features of a design must be justified by concrete performance and cost numbers, and not by vague ideas about what might be useful or not useful to have in a CPU. What is frustrating when looking at modern CPU or GPU designs, e.g. Zen 4, Raptor Lake or the RTX 4000 series, is that an outside observer cannot really assess whether the CPU or GPU design teams have done a good job or not. An outside observer can measure the performance, i.e. the speed and energy consumption of a CPU or GPU when performing certain tasks, but there is no access to the cost information, which is a closely guarded secret, because foundries like TSMC do not provide design rules information, unless you are a potential big customer. So an outsider cannot judge whether the current CPU and GPU architectures and micro-architectures are the best that can be done, or significant improvements are possible.
- brucehoult 4y ago>Zero-wait-state memory was still a thing in workstations up to the 90s; there was no latency of loads from memory. That is not correct. Even PCs started to get caches in around 1985-1987. In 1985 the 80386 supported an optional external SRAM cache. In 1984 the 68020 had a 256 byte instruction cache. 1987's 68030 added a 256 byte data cache. Apple's 1989 Mac IIci added an optional 16k external cache to the 68030, which was actually bought by everyone I knew who had one, as it made a considerable speed difference. The 80486 (1989) and 68040 (1990) had 8k unified and 4k+4k I&D caches respectively. RISC workstations of course had caches before Macs&PCs did.
- kragen 4y agoI appreciate the corrections, and I think I went through most of these in my earlier comment https://news.ycombinator.com/item?id=33059665 https://news.ycombinator.com/item?id=33059665 but I had the impression that the reason for the caches was mostly to reduce the required memory bandwidth. This is of course a stronger reason for an icache than a dcache. As you can see in that thread, I haven't been able to find any shipping RISC CPUs that had a cache before the 68020 in 01984. In particular I haven't found evidence that the ROMP had a cache, even though it was derived from the split-cache 801. Maybe you know of some? I must have been wrong about the latency of DRAM in the late 01980s. Even today I suppose single-banked DRAM usually tops out at 10 MHz for random accesses?
- adrian_b 4y agoIntel 8086/8088 had slow memory access, an access cycle was at least 4 clock cycles and it was easy to find DRAM that would not need wait cycles, e.g. for an IBM PC/XT. Intel 80286 has completely changed the memory bus and it could complete a memory access in only 2 clock cycles, and inside those 2 clock cycles there was little time from when the address was available until the data had to be returned by the memory for no wait states. Even for the first model of IBM PC/AT, with a very slow 80286 @ 6 MHz (despite the fact that 80286 had been officially launched with clock frequencies starting at 8 MHz), it would have been difficult to find fast enough DRAM to avoid the wait states. The desire of minimizing or avoiding the wait states could have been the reason for the very low clock frequency, unless Intel had manufacturing problems and could not supply enough 80286 @ 8 MHz or @ 12 MHz. For the later faster 80286 models and for the 80386, which started in 1985 at 12 MHz and 16 MHz, it was pretty much impossible to find DRAM that would allow a 2-clock-cycle memory access cycle. The majority of the PC/AT clones with 80286 or 80386 used one or more wait states for the DRAM and all the high-end PC/AT clones with 80386DX CPUs had external cache memories made with fast SRAM, e.g. of 32 kbyte or 64 kbyte size, which was the only memory that could be used without wait states. Even after Intel included the L1 cache in 486 and Pentium, all the decent motherboards had an external L2 cache with SRAM. The external caches have disappeared only after 2000, when the later models of Intel Pentium III and AMD Athlon have included on the chip also the L2 cache memory.