Minutes from Feb 21 LSE Call
Linus brought back tablets from the mount on which were graven:
Quoted 3 lines
The x86 is a hell of a lot nicer than the ppc32, for example. On the x86, you get good performance and you can ignore the design mistakes (ie segmentation) by just basically turning them off.
Now wait a minute. I thought you worked at Transmeta.
There were no development and debugging costs associated with getting all those different kinds of gates working, and all the segmentation checking right?
Wouldn't it have been easier to build the system, and shift the effort where it would really do some good, if you didn't have to support all that crap?
An extra base/bounds check doesn't take any die area? An extra exception source doesn't complicate exception handling?
Quoted 6 lines
And the baroque instruction encoding on the x86 is actually a _good_
thing: it's a rather dense encoding, which means that you win on icache. It's a bit hard to decode, but who cares? Existing chips do well at decoding, and thanks to the icache win they tend to perform better - and they load faster too (which is important - you can make your CPU have big caches, but _nothing_ saves you from the cold-cache costs).
I *really* thought you worked at Transmeta.
Transmeta's software-decoding is an extreme example of what all modern x86 processors are doing in their L1 caches, namely predecoding the instructions and storing them in expanded form. This varies from just adding boundary tags (Pentium) and instruction type (K7) through converting them to uops and cacheing those (P4).
This exactly undoes any L1 cache size benefits. The win, of course, is that you don't have as much shifting and aligning on your i-fetch path, which all the fixed-instruction-size architectures already started with.
So your comments only apply to the L2 cache.
And for the expense of all the instruction predecoding logic betweeen L2 and L1, don't you think someone could build an instruction compressor to fit more into the die-size-limited L2 cache? With the sizes cache likes are getting to these days, you should be able to do pretty well. It seems like 6 of one, half dozen of the other, and would save the compiler writers a lot of pain.
Quoted 8 lines
The low register count isn't an issue when you code in any high-level language, and it has actually forced x86 implementors to do a hell of a lot better job than the competition when it comes to memory loads and stores - which helps in general. While the RISC people were off trying to optimize their compilers to generate loops that used all 32 registers efficiently, the x86 implementors instead made the chip run fast on varied loads and used tons of register renaming hardware (and looking at _memory_ renaming too).
I don't disagree that chip designers have managed to do very well with the x86, and there's nothing wrong with making a virtue out of a necessity, but that doesn't make the necessity good.
I was about to raise the same point. L1 dcache access tends to be a cycle-limiting bottleneck, and as pearly as the original Pentium, the x86 had to go to a 2-access-per-cycle L1 dcache to avoid bottlenecking with only 2 pipes!
The low register count *does* affect you when using a high-level language, because if you have too many live variables floating around, you start suffering. Handling these spills is why you need memory renaming.
It's true that x86 processors have had fancy architectural features sooner than similar-performance RISCs, but I think there's a fair case that that's because they've *needed* them. Why do the P4 and K7/K8 have such enormous reorder buffers, able to keep around 100 instructions in flight at a time? Because they need it to extract parallelism out of an instruction stream serialized by a miserly register file.
They've developed some great technology to compensate for the weaknesses, but it's sure nice to dream of an architecture with all that great technology but with fewer initial warts. (Alpha seemed like the best hope, but *sigh*. Still, however you apportion blame for its demise, performance was clearly not one of its problems.)
I think the same claim applies much more powerfully to the ppc32's MMU. It may be stupid, but it is only visible from inside the kernel, and a fairly small piece of the kernel at that.
It could be scrapped and replaced with something better without any effect on existing user-level code at all.
Do you think you can replace the x86's register problems as easily?
Quoted 1 line
The only real major failure of the x86 is the PAE crud.
So you think AMD extended the register file just for fun?
Hell, the "PAE crud" is the *same* problem as the tiny register file. Insufficient virtual address space leading to physical > virtual kludges.
And, as you've noticed, there are limits to the physical/virtual ratio above which it gets really painful. And the 64G:4G ratio of PAE is mirrored in the 128:8 ratio of P4 integer registers.
I wish the original Intel designers could have left a "no heroic measures" living will, because that design is on more life support than Darth Vader.
Quoted 6 lines · On 24 Feb 2003 [email protected] wrote:
Now wait a minute. I thought you worked at Transmeta.
There were no development and debugging costs associated with getting all those different kinds of gates working, and all the segmentation checking right?
So? The only thing that matters is the end result.
Quoted 3 lines
Wouldn't it have been easier to build the system, and shift the effort where it would really do some good, if you didn't have to support all that crap?
Probably not appreciably. You forget - it's been tried. Over and over again. The whole RISC philosophy was all about "wouldn't it perform better if you didn't have to support that crap".
The fact is, the "crap" doesn't matter that much. As proven by the fact that the "crap" processor family ends up being the one that eats pretty much everybody else for lunch on performance issues.
Yes, the "crap" does end up making it a harder market to enter. There's a lot of IP involved in knowing what all the rules are, and having literally _millions_ of tests that check for conformance to the architecture (and much of the "architecture" is a de-facto thing, not really written down in architecture manuals).
But clearly even that is not insurmountable, as shown by the fact that not only does the x85 perform well, it's also one of the few CPU's that are actively worked on by multiple different companies (including Transmeta, as you point out - although clearly the "crap" is one reason why the sw approach works at all).
Quoted 5 lines
Transmeta's software-decoding is an extreme example of what all modern x86 processors are doing in their L1 caches, namely predecoding the instructions and storing them in expanded form. This varies from just adding boundary tags (Pentium) and instruction type (K7) through converting them to uops and cacheing those (P4).
But you seem to imply that that is somehow a counter-argument to _my_ argument. And I don't agree.
I think what Transmeta (and AMD, and VIA etc) show is that the ugliness doesn't really matter - there are different ways of handling it, and you can either throw hardware at it or software at it, but it's still worth doing, because in the end what matters is not the bad parts of it, but the good parts.
Btw, the P4 tracecache does pretty much exactly the same thing that Transmeta does, except in hardware. It's based on a very simple reality:
decoding _is_ going to be the bottleneck for _any_ instruction set, once you've pushed the rest hard enough. If you're not doing predecoding, that only means that you haven't pushed hard enough yet - _regardless_ of your archtiecture.
Quoted 3 lines
This exactly undoes any L1 cache size benefits. The win, of course, is that you don't have as much shifting and aligning on your i-fetch path, which all the fixed-instruction-size architectures already started with.
No. You don't understand what "cold-cache" case really means. It's more than just bringing the thing in from memory to the cache. It's also all about loading the dang thing from disk.
Quoted 1 line
So your comments only apply to the L2 cache.
And the disk.
Quoted 3 lines
And for the expense of all the instruction predecoding logic betweeen L2 and L1, don't you think someone could build an instruction compressor to fit more into the die-size-limited L2 cache?
It's been done. See the PPC stuff. I've read the papers (it's been a long time, admittedly - it's not something new), and the fact is, it's not apparently being used that much. Because it's quite painful, unlike the x86 approach.
Quoted 9 lines
Quoted 5 lines
stores - which helps in general. While the RISC people were off trying to optimize their compilers to generate loops that used all 32 registers efficiently, the x86 implementors instead made the chip run fast on varied loads and used tons of register renaming hardware (and looking at _memory_ renaming too).
I don't disagree that chip designers have managed to do very well with the x86, and there's nothing wrong with making a virtue out of a necessity, but that doesn't make the necessity good.
Actually, you miss my point.
The necessity is good because it _forced_ people to look at what really matters. Instead of wasting 15 years and countless PhD's on things that are, in the end, just engineering-masturbation (nr of registers etc).
Quoted 3 lines
The low register count *does* affect you when using a high-level language, because if you have too many live variables floating around, you start suffering. Handling these spills is why you need memory renaming.
Bzzt. Wrong answer.
The right answer is that you need memory renaming and memory alias hardware _anyway_, because doing dynamic scheduling of loads vs stores is something that is _required_ to get the kind of performance that people expect today. And all the RISC stuff that tried to avoid it was just a BIG WASTE OF TIME. Because the _only_ thing the RISC approach ended up showing was that eventually you have to do the hard stuff anyway, so you might as well design for doing it in the first place.
Which is what ia-64 did wrong - and what I mean by doing the same mistakes that everybody else did 15 years ago. Look at all the crap that ia64 does in order to do compiler-driven loop modulo-optimizations. That's part of the whole design, with predication and those horrible register windows. Can you say "risc mistakes all over again"?
My strong suspicion (and that makes it a "fact" ;) is that in another 5 years they'll get to where the x86 has been for the last 10 years, and they'll realize that they will need to do out-of-order accesses etc, which makes all of that modulo optimization pretty much useless, since the hardware pretty much has to do it _anyway_.
Quoted 3 lines
It's true that x86 processors have had fancy architectural features sooner than similar-performance RISCs, but I think there's a fair case that that's because they've *needed* them.
Which is exactly my point. And by the time you implement them, you notice that the half-way measures don't mean anything, and in fact make for more problems.
For example, that small register state is a pain in the ass, no? But since you basically need register renaming _anyway_, the small register state actually has some advantages in that it makes it easier to have tons of read ports and still keep the register file fast. And once you do renaming (including memory state renaming), IT DOESN'T MUCH MATTER.
Quoted 4 lines
Why do the P4 and K7/K8 have
such enormous reorder buffers, able to keep around 100 instructions in flight at a time? Because they need it to extract parallelism out of an instruction stream serialized by a miserly register file.
You think this is bad?
Look at it another way: once you have hundreds of instructions in flight, you have hardware that automatically
- executes legacy applications reasonably well, since compilers aren't the most important thing.
End result: users are happy.
- you don't need to have compilers that do stupid things like unrolling loops, thus keeping your icache pressure down, since you do loop unrolling in hardware thanks to deep pipelines.
Even the RISC people are doing hundreds of instructions in flight (ie Power5), but they started doing it years after the x86 did, because they claimed that they could force their users to recompile their binaries every few years. And look where it actually got them..
Quoted 5 lines
They've developed some great technology to compensate for the weaknesses, but it's sure nice to dream of an architecture with all that great technology but with fewer initial warts. (Alpha seemed like the best hope, but *sigh*. Still, however you apportion blame for its demise, performance was clearly not one of its problems.)
So my premise is that you always end up doing the hard things anyway, and the "crap" _really_ doesn't matter.
Alpha was nice, no question about it. But it took them way too long to get to the whole OoO thing, because they tried to take a short-cut that in the end wasn't the answer. It _looked_ like the answer (the original alpha design was done explicitly to not _need_ things like complex out-of-order execution), but it was all just wrong.
The thing about the x86 is that hard cold reality (ie millions of customers that have existign applications) really _forces_ you to look at what matters, and so far it clearly appears that the things you are complaining about (registers and segmentation) simply do _not_ matter.
Quoted 8 lines
I think the same claim applies much more powerfully to the ppc32's MMU. It may be stupid, but it is only visible from inside the kernel, and a fairly small piece of the kernel at that.
It could be scrapped and replaced with something better without any effect on existing user-level code at all.
Do you think you can replace the x86's register problems as easily?
They _have_ been solved. The x86 performs about twice as well as any ppc32 on the market. End of discussion.
Quoted 3 lines
Quoted 1 line
The only real major failure of the x86 is the PAE crud.
So you think AMD extended the register file just for fun?
I think the AMD register file extension was unnecessary, yes. They did it because they could, and it wasn't a big deal. That's not the part that makes the architecture interesting. As you should well know.
Quoted 3 lines
Hell, the "PAE crud" is the *same* problem as the tiny register file. Insufficient virtual address space leading to physical > virtual kludges.
Nope. The small register file is a non-issue. Trust me. I do work for transmeta, and we do the register renaming in software, and it doesn't matter in the end.
Linus
also the RISC argument was started back when the CPU ran at the same speed as memory and CISC was limited to slow clock speeds, the RISC folks figured that if they could eliminate the CISC complexity they could ratchet up the clock speeds and more then make up for the other inefficiancies.
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are as fast or faster then the 'high speed' RISC cores.
so the remaining difference between CISC and RISC really isn't the core functions, it's where do the optimizations take place.
in CISC they take place on the CPU (either in software or hardware) in RISC they take place in the compiler
unfortunantly for the RISC folks the optimizations change significantly from chip to chip and so the code needs to be compiled for each chip (in many cases each motheboard) to take full advantage of them. while this could be acceptable in an OpenSource world in the real world of pre-compiled binaries companies are not interested in shipping a dozen versions of a program so there is no preasure for the compilers to get optimized this well (besides the problem of people not wanting to use the 'blessed' compiler), and software development always laggs hardware so the compilers are never available when the CPUs are (and at the pace of development by the time they are availabel new CPUs are out) while on the CISC side of the house these optimizations are done in the CPU by the designers of the chips and since the performance of the chips is judged including these optimizations (no way to weasle out by claiming it's a compiler problem) a lot of attention is paid to this work and it's out when the chip is released (at this point both the tranemeta and intel CPUs have the ability to update this code, but it's really only done to fix major bugs)
the other big claim of the RISC folks was that they didn't waste transisters on this since it was done in the compiler, but the transister budget has climbed so high since then that this cost is minimal. I seem to remember that intel claims that enabling hyperthreading (which not only duplicates this entire section, but adds even more to keep them straight) adds less then 10% to the transister count of the CPU. yes it would be nicer to have those transisters available to be used for other things, but experiance with RISC has shown that overall the tradeoff isn't worth it
David Lang
Quoted 220 lines · Linus Torvalds
Date: Sun, 23 Feb 2003 18:39:09 -0800 (PST)
From: Linus Torvalds <[email protected]>
To: [email protected]
Cc: [email protected]
Subject: Re: Minutes from Feb 21 LSE CallQuoted 6 lines · On 24 Feb 2003 [email protected] wrote:
Now wait a minute. I thought you worked at Transmeta.
There were no development and debugging costs associated with getting all those different kinds of gates working, and all the segmentation checking right?
So? The only thing that matters is the end result.
Quoted 3 lines
Wouldn't it have been easier to build the system, and shift the effort where it would really do some good, if you didn't have to support all that crap?
Probably not appreciably. You forget - it's been tried. Over and over again. The whole RISC philosophy was all about "wouldn't it perform better if you didn't have to support that crap".
The fact is, the "crap" doesn't matter that much. As proven by the fact that the "crap" processor family ends up being the one that eats pretty much everybody else for lunch on performance issues.
Yes, the "crap" does end up making it a harder market to enter. There's a lot of IP involved in knowing what all the rules are, and having literally _millions_ of tests that check for conformance to the architecture (and much of the "architecture" is a de-facto thing, not really written down in architecture manuals).
But clearly even that is not insurmountable, as shown by the fact that not only does the x85 perform well, it's also one of the few CPU's that are actively worked on by multiple different companies (including Transmeta, as you point out - although clearly the "crap" is one reason why the sw approach works at all).
Quoted 5 lines
Transmeta's software-decoding is an extreme example of what all modern x86 processors are doing in their L1 caches, namely predecoding the instructions and storing them in expanded form. This varies from just adding boundary tags (Pentium) and instruction type (K7) through converting them to uops and cacheing those (P4).
But you seem to imply that that is somehow a counter-argument to _my_ argument. And I don't agree.
I think what Transmeta (and AMD, and VIA etc) show is that the ugliness doesn't really matter - there are different ways of handling it, and you can either throw hardware at it or software at it, but it's still worth doing, because in the end what matters is not the bad parts of it, but the good parts.
Btw, the P4 tracecache does pretty much exactly the same thing that Transmeta does, except in hardware. It's based on a very simple reality:
decoding _is_ going to be the bottleneck for _any_ instruction set, once you've pushed the rest hard enough. If you're not doing predecoding, that only means that you haven't pushed hard enough yet - _regardless_ of your archtiecture.Quoted 3 lines
This exactly undoes any L1 cache size benefits. The win, of course, is that you don't have as much shifting and aligning on your i-fetch path, which all the fixed-instruction-size architectures already started with.
No. You don't understand what "cold-cache" case really means. It's more than just bringing the thing in from memory to the cache. It's also all about loading the dang thing from disk.
Quoted 1 line
So your comments only apply to the L2 cache.
And the disk.
Quoted 3 lines
And for the expense of all the instruction predecoding logic betweeen L2 and L1, don't you think someone could build an instruction compressor to fit more into the die-size-limited L2 cache?
It's been done. See the PPC stuff. I've read the papers (it's been a long time, admittedly - it's not something new), and the fact is, it's not apparently being used that much. Because it's quite painful, unlike the x86 approach.
Quoted 9 lines
Quoted 5 lines
stores - which helps in general. While the RISC people were off trying to optimize their compilers to generate loops that used all 32 registers efficiently, the x86 implementors instead made the chip run fast on varied loads and used tons of register renaming hardware (and looking at _memory_ renaming too).
I don't disagree that chip designers have managed to do very well with the x86, and there's nothing wrong with making a virtue out of a necessity, but that doesn't make the necessity good.
Actually, you miss my point.
The necessity is good because it _forced_ people to look at what really matters. Instead of wasting 15 years and countless PhD's on things that are, in the end, just engineering-masturbation (nr of registers etc).
Quoted 3 lines
The low register count *does* affect you when using a high-level language, because if you have too many live variables floating around, you start suffering. Handling these spills is why you need memory renaming.
Bzzt. Wrong answer.
The right answer is that you need memory renaming and memory alias hardware _anyway_, because doing dynamic scheduling of loads vs stores is something that is _required_ to get the kind of performance that people expect today. And all the RISC stuff that tried to avoid it was just a BIG WASTE OF TIME. Because the _only_ thing the RISC approach ended up showing was that eventually you have to do the hard stuff anyway, so you might as well design for doing it in the first place.
Which is what ia-64 did wrong - and what I mean by doing the same mistakes that everybody else did 15 years ago. Look at all the crap that ia64 does in order to do compiler-driven loop modulo-optimizations. That's part of the whole design, with predication and those horrible register windows. Can you say "risc mistakes all over again"?
My strong suspicion (and that makes it a "fact" ;) is that in another 5 years they'll get to where the x86 has been for the last 10 years, and they'll realize that they will need to do out-of-order accesses etc, which makes all of that modulo optimization pretty much useless, since the hardware pretty much has to do it _anyway_.
Quoted 3 lines
It's true that x86 processors have had fancy architectural features sooner than similar-performance RISCs, but I think there's a fair case that that's because they've *needed* them.
Which is exactly my point. And by the time you implement them, you notice that the half-way measures don't mean anything, and in fact make for more problems.
For example, that small register state is a pain in the ass, no? But since you basically need register renaming _anyway_, the small register state actually has some advantages in that it makes it easier to have tons of read ports and still keep the register file fast. And once you do renaming (including memory state renaming), IT DOESN'T MUCH MATTER.
Quoted 4 lines
Why do the P4 and K7/K8 have
such enormous reorder buffers, able to keep around 100 instructions in flight at a time? Because they need it to extract parallelism out of an instruction stream serialized by a miserly register file.You think this is bad?
Look at it another way: once you have hundreds of instructions in flight, you have hardware that automatically
- executes legacy applications reasonably well, since compilers aren't the most important thing.
End result: users are happy.
- you don't need to have compilers that do stupid things like unrolling loops, thus keeping your icache pressure down, since you do loop unrolling in hardware thanks to deep pipelines.
Even the RISC people are doing hundreds of instructions in flight (ie Power5), but they started doing it years after the x86 did, because they claimed that they could force their users to recompile their binaries every few years. And look where it actually got them..
Quoted 5 lines
They've developed some great technology to compensate for the weaknesses, but it's sure nice to dream of an architecture with all that great technology but with fewer initial warts. (Alpha seemed like the best hope, but *sigh*. Still, however you apportion blame for its demise, performance was clearly not one of its problems.)
So my premise is that you always end up doing the hard things anyway, and the "crap" _really_ doesn't matter.
Alpha was nice, no question about it. But it took them way too long to get to the whole OoO thing, because they tried to take a short-cut that in the end wasn't the answer. It _looked_ like the answer (the original alpha design was done explicitly to not _need_ things like complex out-of-order execution), but it was all just wrong.
The thing about the x86 is that hard cold reality (ie millions of customers that have existign applications) really _forces_ you to look at what matters, and so far it clearly appears that the things you are complaining about (registers and segmentation) simply do _not_ matter.
Quoted 8 lines
I think the same claim applies much more powerfully to the ppc32's MMU. It may be stupid, but it is only visible from inside the kernel, and a fairly small piece of the kernel at that.
It could be scrapped and replaced with something better without any effect on existing user-level code at all.
Do you think you can replace the x86's register problems as easily?
They _have_ been solved. The x86 performs about twice as well as any ppc32 on the market. End of discussion.
Quoted 3 lines
Quoted 1 line
The only real major failure of the x86 is the PAE crud.
So you think AMD extended the register file just for fun?
I think the AMD register file extension was unnecessary, yes. They did it because they could, and it wasn't a big deal. That's not the part that makes the architecture interesting. As you should well know.
Quoted 3 lines
Hell, the "PAE crud" is the *same* problem as the tiny register file. Insufficient virtual address space leading to physical > virtual kludges.
Nope. The small register file is a non-issue. Trust me. I do work for transmeta, and we do the register renaming in software, and it doesn't matter in the end.
Linus
-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Quoted 3 lines · In article <[email protected]> you…
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are as fast or faster then the 'high speed' RISC cores.
Hmm.. are there any RISC Cores which run even closely to CISC Speeds?
And why not? Is this only the financial power of Intel?
Bernd
Quoted 3 lines · In article <...> someone wrote:
Quoted 3 lines
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are as fast or faster then the 'high speed' RISC cores.
Quoted 2 lines · Bernd Eckenfels
Hmm.. are there any RISC Cores which run even closely to CISC Speeds? And why not? Is this only the financial power of Intel?
There is one other: x86 binary compatibility.
Looks like the beginning and end of it to me.
-- wli
Quoted 5 lines · William Lee Irwin III
Quoted 3 lines · In article <...> someone wrote:
Quoted 3 lines
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are as fast or faster then the 'high speed' RISC cores.
Quoted 7 lines
Quoted 2 lines · Bernd Eckenfels
Hmm.. are there any RISC Cores which run even closely to CISC Speeds? And why not? Is this only the financial power of Intel?
There is one other: x86 binary compatibility.
Looks like the beginning and end of it to me.
it's more then just the financial power of Intel, AMD is also in many ways above the performance of the 'high-end' processors
aceshardware has a chart showing several different processors (dated in october 2002 so it's not _that_ out of date
http://www.aceshardware.com/read_news.jsp?id=60000436
one interesting thing I see from this chart is that the x86 processors are well ahead in integer performance and pulling further ahead (the pace of development is significantly faster then the other processors) while they do lag in floating point (but not by that much) there are a LOT of workloads where the floating point performance is not as important (the K2 showed that it can't lag _to_ far behind)
the x86 binary compatability means that even a 'low volume' x86 compatable chip has a large potential market and a company can do reasonably well getting a small percentage of the market (see the transmeta and cyrix shiips) while the non x86 chips (including ia64) have to invent a new market segment for themselves.
David Lang
Am Mit, 2003-02-26 um 06.30 schrieb Bernd Eckenfels:
Quoted 5 lines
Quoted 3 lines
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are as fast or faster then the 'high speed' RISC cores.
Hmm.. are there any RISC Cores which run even closely to CISC Speeds?
Define RISC and CISC: do you mean pure RISC implementations or RISC implementations with CISC frontend?
Define Speed: Felt speed, clock speed or measurable speed?
I'm convinced that for each (sensible) combination of definations above there's a clear indication that your question is wrong.
Signature · 2 lines
Servus,
DanielQuoted 10 lines · Daniel Egger
Date: Thu, 27 Feb 2003 09:50:21 -0800
From: Daniel Egger <[email protected]>
To: Bernd Eckenfels <[email protected]>
Cc: [email protected]
Subject: Re: Minutes from Feb 21 LSE CallAm Mit, 2003-02-26 um 06.30 schrieb Bernd Eckenfels:
Quoted 2 lines
Quoted 2 lines
unfortunantly for them the core CPU speeds became uncoupled from the memory speeds and skyrocketed up to the point where CISC cores are
Quoted 7 lines
as fast
Quoted 3 lines
Quoted 1 line
or faster then the 'high speed' RISC cores.
Hmm.. are there any RISC Cores which run even closely to CISC Speeds?
Define RISC and CISC: do you mean pure RISC implementations or RISC implementations with CISC frontend?
as far as programmers and users are concerned there is no difference between CISC and RISC with a CISC front-end (transmeta is the most obvious example of this, but all current CISC chips use this technique)
Quoted 1 line
Define Speed: Felt speed, clock speed or measurable speed?
for my origional post I was refering to pure clock speeds, remember that the origional RISC chips came out when CISC chips were just starting to hit 60MHz and a large part of their claim was that it didn't matter if the chip got less done per clock becouse they could run at much higher speeds (a couple hundred MHz). Also the Instructions per Clock for CISC chips was very high with the RISC chips pushing towards 1 IPC.
the reasoning was that there was no way to implement all the complicated CISC instruction set decoding and options and achieve anything close to the clock speeds that the nice streamlined RISC chips could reach.
when the RISC chip cores are just over 1GHz and talking about possibly hitting 1.8GHz within a year or so the intel chips are pushing 3GHz while the AMD chips are pushing 2GHz (true speed, I'll avoid commenting on the mistakes that intel made on the P4 that make these chips competitive with each other :-)
and the IPC of current CISC implementations is pushing towards 1 as well (insert disclaimer about benchmarks) so RISC no longer has a huge advantage there either.
obviously higher clock speeds to not directly equate to higher performance, but as Linus has pointed out there are a lot of efficiancies in the CISC command set that mean that if you have two chips running at the same clockspeed with the same IPC the CISC command set will outperform the RISC one.
the only serious advantage the RISC chips have today is the fact that they are 64 bit instead of 32 bit, and x86-64 will erase that limitation.
David Lang
Quoted 7 lines
I'm convinced that for each (sensible) combination of definations above there's a clear indication that your question is wrong.
--
Servus,
Daniel
Quoted 5 lines · David Lang
Quoted 4 lines · Daniel Egger
Am Mit, 2003-02-26 um 06.30 schrieb Bernd Eckenfels:
Quoted 2 lines
Hmm.. are there any RISC Cores which run even closely to CISC Speeds?
Quoted 7 lines
Quoted 1 line
Define Speed: Felt speed, clock speed or measurable speed?
when the RISC chip cores are just over 1GHz and talking about possibly hitting 1.8GHz within a year or so the intel chips are pushing 3GHz while the AMD chips are pushing 2GHz (true speed, I'll avoid commenting on the mistakes that intel made on the P4 that make these chips competitive with each other :-)
And they need what kind of cooling to get there? Compare that to a passively cooled G4.[1]
This is AFAIK not true for every RISC chip, I believe current ultrasparc and alpha even more so do need significant cooling as well. But IMO your question is not really relevant to the discussion, as especially the common CISC examples you are referring to are artificially pushed to higher clock speeds. Compare those to a passively cooled transmeta or via chip and it you can ask about clock speeds CISC vs CISC instead of CISC vs RISC.
Or compare a Transmeta or Via chip with RISC cores and see who wins the clockspeed race then :-)
Regards,
Filip
[1] Yes, those dual powermacs have a case exhaust fan which draws air over the CPUs' fin. So has the fastest passively cooled, not clocked down intel desktop I've ever seen, a 300MHz pII Dell Dimension. (That's also still the most silent "high-end" intel desktop I've ever seen)
Signature · 2 lines
"The only stupid question is the unasked one." -- Martin Schulze
El día Thu, 27 Feb 2003 10:25:23 -0800 (PST) David Lang <[email protected]> escribió...
Quoted 2 lines
when the RISC chip cores are just over 1GHz and talking about possibly hitting 1.8GHz within a year or so the intel chips are pushing 3GHz while
I suppose eveybody has seen this... (today on slashdot ;):
http://apple.slashdot.org/article.pl?sid=03/02/27/2227257&mode=thread&tid=136
"PowerPC 970 Running at 2.5 GHz"
Quoted 2 lines · Arador
I suppose eveybody has seen this... (today on slashdot ;):
http://apple.slashdot.org/article.pl?sid=03/02/27/2227257&mode=thread&tid=136
In a lab... who cares.
I would guess the P4s or whatever are at 5GHz+ in Intel's labs.
--cw
Quoted 8 lines · Chris Wedgwood
Quoted 2 lines · Arador
I suppose eveybody has seen this... (today on slashdot ;):
http://apple.slashdot.org/article.pl?sid=03/02/27/2227257&mode=thread&tid=136In a lab... who cares.
I would guess the P4s or whatever are at 5GHz+ in Intel's labs.
Last time I checked ( one year ago ), they were running a cooled ALU at 10GHz.
- Davide
this implies that when the new chip is released it may be up to 2.5GHz instead of the 1.8GHz previously listed.
Ok, this means that a year or so from now when the chip is released it will have clock speeds in the range of todays x86 chips. this is at least in the ballpark to remain competitive.
David Lang
Quoted 19 lines · Chris Wedgwood
Date: Fri, 28 Feb 2003 16:51:49 -0800
From: Chris Wedgwood <[email protected]>
To: Arador <[email protected]>
Cc: David Lang <[email protected]>, [email protected],
[email protected], [email protected]
Subject: Re: Minutes from Feb 21 LSE CallQuoted 2 lines · Arador
I suppose eveybody has seen this... (today on slashdot ;):
http://apple.slashdot.org/article.pl?sid=03/02/27/2227257&mode=thread&tid=136In a lab... who cares.
I would guess the P4s or whatever are at 5GHz+ in Intel's labs.
--cw
Am Sam, 2003-03-01 um 02.27 schrieb David Lang:
Quoted 6 lines
this implies that when the new chip is released it may be up to 2.5GHz instead of the 1.8GHz previously listed.
Ok, this means that a year or so from now when the chip is released it will have clock speeds in the range of todays x86 chips. this is at least in the ballpark to remain competitive.
From a pure clock point of view. For some reallife performance rather look at the SPEC numbers. Actually I don't care about the clocking of a processor especially when vendors are pushing it with longer pipelines as this is all marketing crap (and let's see what problems Intel will face with the Centrino architecture to tell that lower clocks might bring higher performance with a different design).
BTW: Distributed.net client has now an AltiVec implementation which makes an G4/500 eat an Athlon/1.8GHz for breakfast...
Signature · 2 lines
Servus,
DanielQuoted 3 lines
The fact is, the "crap" doesn't matter that much. As proven by the fact that the "crap" processor family ends up being the one that eats pretty much everybody else for lunch on performance issues.
But is that because it's a better design? Or because it has more money thrown at it? I suspect it's merely it's mass-market dominance generating huge amounts of cash to improve it ... and it got there through history, not technical prowess.
Of course, to be pragmatic about it, none of this matters. The chip with the best price:performance and market presence wins, not the best technical design.
M.
Quoted 9 lines · Martin J. Bligh
Quoted 4 lines
The fact is, the "crap" doesn't matter that much. As proven by the fact that the "crap" processor family ends up being the one that eats pretty much everybody else for lunch on performance issues.
But is that because it's a better design? Or because it has more money thrown at it? I suspect it's merely it's mass-market dominance generating huge amounts of cash to improve it ... and it got there through history, not technical prowess.
Sure. It's to a large degree "more money and resources", no question about that.
But what is "better design"? Would it have been possible to put as much effort as Intel (and others) put into the x86 architecture into something else, and make it even better?
MY standpoint is that the above question is _meaningless_ and stupid. People did try. Very hard. Claiming anything else is clearly misguided. But compatibility and price matter equally much - and often more - than raw performance. Which means that even _if_ another architecture performed better (and it certainly happened, in the hay-day of the alpha), it wouldn't much matter. People still stayed away from it in droves.
And in the end, that's why I don't like IA-64. I'll take back every single bad thing I've ever said about IA-64 if Intel were to just to sell those things to the mass market instead of P4's. But clearly the IA-64 can't make it in that market, and thus it is made irrelevant. The same way alpha was made irrelevant, _despite_ having had much better performance - an advantage that ia-64 clearly doesn't have.
(Admittedly, alpha didn't have hugely better performance for very long. Intel came out with the PPro, and took a _lot_ of people by surprise).
AMD's x86-64 approach is a lot more interesting not so much because of any technical issues, but because AMD _can_ try to avoid the "irrelevant" part. By having a part that _can_ potentially compete in the market against a P4, AMD has something that is worth hoping for. Something that can make a difference.
IBM with Power5 and apple could be the same thing (yeah yeah, I personally suspect it goes enough against IBMs normal approach that it will cause some friction). A CPU that actually competes in a market that is relevant.
Because server CPU's simply aren't very interesting from a technical standpoint. I don't know of a _single_ CPU that ever grew down. But we've seen a _lot_ of CPU's grow _up_. In other words: the small machines tend to eat into the large ones, not the other way around.
And if you start from the large ones, you aren't going to make it in the long run.
Put yet another way: if I was on Intels IA-32 team, I'd be a lot more worried about those XScale people finally getting their act together than I would be about IA-64.
Linus