4 ms·
I wonder if the whole thing with enormously complex CPUs requiring deep pipelines which in turn requires complex speculation etc was a design mistake? Is there
by alkonaut 9y ago
I wonder if the whole thing with enormously complex CPUs requiring deep pipelines which in turn requires complex speculation etc was a design mistake? Is there an alternative history where mainstream CPUs are equally fast with a dumber/simpler design?
- richardwhiuk 9y agoNot that we currently know about. RISC instead of CISC is better here as it shortens the pipeline, but even RISC processors do speculative predictions due to the cost of waiting till a branch is fully decided.
- alkonaut 9y agoWhat about more radically different designs? E.g Mill or others?
- mike_hearn 9y agoThe Mill does prediction: https://millcomputing.com/docs/prediction/ https://millcomputing.com/docs/prediction/ It has to. The problem is the speed of light here, not a simple slipup by a CPU designer.
- alkonaut 9y agoSo all that needs to be done is make 64GB L1 on the die...
- richardwhiuk 9y agoNot possible - the physical size of 64GB (even at nm scale) means that the time it takes for a signal to traverse it causes memory to take a long time to access, meaning you need a L0 cache to maintain performance.
- ant6n 9y agoWe need to go 3d
- deleted 9y ago[deleted]
- gpderetta 9y agoThe vulnerability window is proportional to the size of the reorder buffer (hundreds of instructions); the pipeline length (tens of stages) is not important (except on strictly in order CPUs with no reorder buffer I guess). Also modern OoO CISCs and RISCs have very similar pipeline depths for the same performance/power budget.
- Havoc 9y agoThe speed gains are very real so I wouldn't call it a mistake. Side-effects could obviously been mitigated better, but hindsight 20/20.
- cesarb 9y agoWhat requires the complex speculation is not the pipeline depth, it's the memory access latency. Consider the following simple C code: "if (arr[idx]) { ... }". Without speculation, the core must stall until the condition has been read from memory, which can be hundreds of cycles if it's not in the cache. With speculation, these wasted cycles are instead used to do some of the work from most probable side of the branch, so when the condition finally arrives from memory, there's less work left to do. The pipeline depth only affects what happens when the speculation predicted the wrong way: since the correct way is not on the pipeline, it has to fill the pipeline from scratch.
- JdeBP 9y agoThere may well be. One alternative design that could have become the mainstream is VLIW. One of the features of VLIW is the idea of predication. Instead of a branch instruction altering the instruction fetch stream based upon the value of a flag bit in some form of condition code register, instruction syllables are encoded with predicates which simply control whether or not the instruction syllable has any effect, based upon the value of a flag bit in some form of predicate register. VLIW is not a panacaea, engineering being all about tradeoffs after all. But it was intended to not have the complex instruction dispatching logic, with things like speculative execution and branch prediction, in the processor. Instead, using a process called if-conversion the compiler combines the two possible results of a conditional branch into a single instruction stream where predicates control which instruction syllables are executed. * http://web.eecs.umich.edu/~mahlke/papers/1996/schlansker_hpl96.pdf http://web.eecs.umich.edu/~mahlke/papers/1996/schlansker_hpl... * https://www.isi.edu/~youngcho/cse560m/vliw.pdf https://www.isi.edu/~youngcho/cse560m/vliw.pdf * https://www.cse.umich.edu/awards/pdfs/p45-mahlke.pdf https://www.cse.umich.edu/awards/pdfs/p45-mahlke.pdf * http://web.eecs.umich.edu/~mahlke/papers/1996/schlansker_hpl96.pdf http://web.eecs.umich.edu/~mahlke/papers/1996/schlansker_hpl... Observe, in considering this alternative history, that the Itanium had 64 predicate registers. People have, in the past few days in various discussions of this subject, criticized Intel for holding on to a processor design for decades and prioritizing backwards compatibility over cleaner architecture. They have forgotten that Intel actually produced a cleaner architecture, back in the 1990s.