Why Do We Use x86 CPUs? 552
bluefoxlucid asks: "With Apple having now switched to x86 CPUs, I've been wondering for a while why we use the x86 architecture at all. The Power architecture was known for its better performance per clock; and still other RISC architectures such as the various ARM models provide very high performance per clock as well as reduced power usage, opening some potential for low-power laptops. Compilers can also deal with optimization in RISC architectures more easily, since the instruction set is smaller and the possible scheduling arrangements are thus reduced greatly. With Just-in-Time compilation, legacy x86 programs could be painlessly run on ARM/PPC by translating them dynamically at run time, similar to how CIL and Java work. So really, what do you all think about our choice of primary CPU architecture? Are x86 and x86_64 a good choice; or should we have shot for PPC64 or a 64-bit ARM solution?" The problem right now is that if we were going to try to "vote with our wallets" for computing architecture, the only vote would be x86. How long do you see Intel maintaining its dominance in the home PC market?
Easy (Score:5, Insightful)
PC architecture sits in a local minima where the fastest route to greater profits lies in improving existing designs, rather than developing new approaches.
The reason "We" use x86 is because "we" use PCs, where x86 technology is dominant and obvious. However, "we" also use PDAs, cell phones, TiVos and even game console systems. As the functions of those devices melt into a new class of unified devices, other architectures will advance.
The real irony is that, for most of these other devices, the underlying architecture is invisible. Few know that Palm switched processors a few years back. Fewer still know what kind of cpu powers their cell phone.
Re:Easy (Score:5, Funny)
Re: (Score:3, Funny)
Re:Easy (Score:5, Funny)
Silly rabits, x86 has been RISC core since PPro (Score:5, Informative)
Re: (Score:3, Informative)
Just to clarify, IA-64 [wikipedia.org] was implemented only in Itanium processors, and is unrelated to x86-64. Intel themselves tried to break away from the x86 line, and the market wasn't very receptive, which is part of what drove the creation of x86-64 instead by AMD.
THESE are the reasons we use x86 (Score:5, Insightful)
2. Total backward-compatibility of the API for the last 20+ years. Even Windows doesn't offer such amazing compatibility modes.
3. Every fundamental architectural improvement in CPU design has been integrated into the x86 family. Academics and designers alike said it was impossible, but x86 today enjoys all the benefits of RISC, pipelining, superscalar design, branch prediction, out-of-order execution, register renaming, symmetric multi-threading and multi-processing, real-time voltage and frequency adjustment...you name it, it has been implemented on an x68 processor.
These reasons are why everyone still uses x86. These reasons are why x86-64 is the predominant 64-bit architecture, and will be for some time. The die overhead for the compatibility and translation layers on modern processes is tiny, so why the hell not keep using it?
Re: (Score:3, Informative)
Re:Easy (Score:5, Interesting)
Honestly, I think it is much simpler than that
The problem has very little to do with the processors that are used and is entirely related to the software that we run. Even in the 80s/90s it would have been completely possible for Microsoft to support a wide range of processors ( if their OS was designed correctly ) and produce OS related libraries which abstracted software development from needing to directly access the underlying hardware; on install, necessary files would be re-compiled and all over the shelf software could run on any architecture that Windows/dos supported. In general, the concept is combining standard C/C++ with libraries (like OpenGL) and recompiling to ensure that no one was tied to a particular hardware architecture.
Just think of how many different architectures Linux has been ported to, if DOS/Windows was built in a similar way you'd be able to choose between any architecture you wanted and still be able to run any program you wanted.
Re: (Score:3, Insightful)
I really wouldn't have wanted to wait that long to install Office or DevStudio.
Re: (Score:2)
Compiling from source could have (potentially) have taken too long for most setups, but that doesn't mean that the general idea was impossible. If you started from an intermediate step in the compile process you could (hypothetically) greatly reduce the compile time, or (after 95 or so when CD players were available on most PCs) you could have included dozens of binaries for the most common setups and the source code in case someone wanted to run the program on hardware that wasn't currently support
Re: (Score:3, Insightful)
Even so, there are pretty major difficulties, even now, with the idea of write once, run anywhere. Although the interface to a library may be standard across multiple platforms, it isn't necessarily the case that the implementation is equally robust, let alone identically so. The observation that it was 'completely possible' neglects any consideration of practicality or commercial viability. I'm not saying that it was too impractical to happen, but you gloss over a
Re:Easy (Score:5, Insightful)
Windows NT was designed to run on i386, MIPS, PPC and Alpha. Over the years, Microsoft discontinued support for the various platforms - IIRC MIPS and Alpha ended with NT3.51 - PPC ended with NT4. NT5 (aka - Windows 2000) was the first i386 only version of NT.
Re: (Score:3, Interesting)
Random note after I clicked submit - The designers of the DEC Alpha chip designed it as a 64bit Big Endian chip. Microsoft convinced DEC to add a feature to the Alpha that switched CPU to a 32bit Little Endian chip so that Microsoft wouldn't have to recode all their the apps that processed binary files with the assumption that integers were four byte little endian.
Re:Easy (Score:5, Insightful)
At the time Microsoft was hedging their bets as everyone ranted about the next generation of RISC chips storming the market. Endlessly we'd hear about how the x86 line was dead, and the only improvements would be to move to the next generation (Intel themselves was heavily focusing on RISC as well -- think of the i860).
We never did because those alternatives never delivered on their promise. Ever since 680x0 processors, the highest performance per dollar crown has been held, with only a couple of very short term or niche exceptions, by the x86 line. When given the option of running software on a variety of platforms, customers always ended up buying the x86.
Look at Linux -- so many platforms supported, yet on the desktop and up level, overwhelmingly it's run on x86. This has been the cast over its history.
Re:Easy (Score:5, Insightful)
We never did because those alternatives never delivered on their promise. Ever since 680x0 processors, the highest performance per dollar crown has been held, with only a couple of very short term or niche exceptions, by the x86 line. When given the option of running software on a variety of platforms, customers always ended up buying the x86.
Look at Linux -- so many platforms supported, yet on the desktop and up level, overwhelmingly it's run on x86. This has been the cast over its history.
As for linux. choice isn't good. People get overwhelmed easily. So anythign more then 2 or 3 choices makes them go cross eyed and buy windows. I myself operate mostly on windows occasionally on red hat/mandrake and very rarely mac OSX.
Re: (Score:3, Insightful)
Not to worry, RISC won the day. x86 chips these days are RISC chips with a thin veneer of x86ness.
Re:Easy (Score:4, Insightful)
I agree that the alternatives never delivered on their promises. That, more than anything else, is why we still use x86. The problem for the alternatives has always been that the liabilities of the x86 design were never as bad as people made them out to be. Certainly the x86 went sideways with the 286, but it returned to sanity again with the 386 and most of those worthless 286 protection modes are just a bit of wasted die area in the microcode array which gets smaller and smaller with each new shrink.
The old story "make is easy for the compilers" is vastly overstated. Modern compilers schedule non-orthogonal register sets extremely well. What is hard for the compilers is crazy amounts of loop unrolling involving asynchronous memory access patterns. Out-of-order execution actually makes life a lot *easier* for the compilers than more rigid approaches such as Itanium or Cell at the cost of extra heat production. Now that we are hitting the thermal wall, maybe it's time for the compilers to finally earn their keep. I've never understood the sentiment of making it easy for the compiler as opposed to, say, writing a very good compiler that implements the best algorithm available.
The key is to choose an aggressive target for what the compiler can reasonably contribute, and then ensure that the compiler achieves that target in a good way. Some of the VLIW efforts stand out in my mind as shining examples of asking the compiler to do a little more than could reasonably be expected. OTOH, I see no reason to simplify an instruction set to the point where a college student could implement the register scheduling algorithm over a long weekend.
Yes, a few things could have been done far better from the outset, such as a more uniform instruction length (though not necessarily as regimented as ARM), a register based floating point unit, and a treatment of the flag register with fewer partial updates. But really, how much else of what was conceived in the early eighties doesn't have greater flaws? We still use email, barely.
The time for debate over instruction sets has long passed. The future debate concerns the integration of heterogenous cores such as the IBM Cell and the future spawn of the AMD/ATI assimilation. I have no doubt someone is out there right now inventing an interconnect everyone will be wistfully lamenting twenty years from now. If only we had known and done something about it (other than this).
After twenty years, it's time to face the music: x86 is more ugly than bad.
Re: (Score:3, Informative)
They probably picked the 8088, rather than the alternative 16 bit processor at the time, the somewhat better Motorolla 68000 used in (expensive) workstations at the time, because of it being very close to the 8 bit 8080/Z-80 chip - which was powering CP/M boxes that were the business software standard. That's why their first choice in operating system vendor was Digital Resear
Re:Easy (Score:4, Informative)
Re: (Score:3, Insightful)
RC1 for W2K was released for for the Alpha - not the final version of W2k - See Wikipedia [wikipedia.org]
Microsoft did do that with NT (Score:3, Informative)
Even in the 80s/90s it would have been completely possible for Microsoft to support a wide range of processors ( if their OS was designed correctly )
Microsoft did do that: there was a time when NT ran on X86, DEC Alpha, and PowerPC machines. (Okay, that's not a huge range, but the point stands.)
X86s became cheaper and cheaper, and continuing development of NT on !X86 became financially infeasible due the rapidly-shrinking market share for non-PC platforms.
Re: (Score:3, Insightful)
Use of Universal binaries (e.g. OS X) wastes disk space that up until recently would have been too costly for most people.
Re: (Score:3, Informative)
Re:Easy (Score:4, Insightful)
And I think this will be increasingly true of the desktop. And since all the best desktop CPUs are x86, it'll probably stay x86.
From an engineering design point of view, it's possible some of these other architectures are cleaner or easier to design or code to, but from a desktop chip and compiler point of view, x86 is the best. It has the best codegen compilers, despite the fact that it may have taken more effort to get to that state, and the CPUs are damn fast at reasonable (although perhaps not optimal) power consumption levels. Talk of theoretical alternate options are academic. Unless one of those other options can produce a chip and compiler that's so much better than x86 that it would be worth moving to, emulation overhead during transition and all, it's not a practical discussion.
Re: (Score:3, Insightful)
Did you seriously just say that designing a computer system and porting a ton of software to it would be easier than creating a controller for a gaming system?
If by 'off the shelf' you mean x86, you haven't done ANYTHING new. If you mean a non-x86, non-PPC processor... You're crazy.
And as your example, you chose a controller for a game system that this company somehow manages to sell for $350, despite competition that sells one for $15. h [gameasylum.us]
Re: (Score:3, Informative)
Once you've go
easy (Score:5, Funny)
momentum (Score:5, Informative)
So don't change unless there is a compelling reason.
Hard to optimize? You only have to optimize the compiler once, over the millions of devices this cost is small.
Runtime interpreter/compilers, you lose the speed advantage.
Volume and competition makes x86 series products cheap
Re: (Score:2, Informative)
Re:momentum (Score:4, Interesting)
Which brings back the other problem; not only are x86 chips cheap to make, but we have 30 years of practice optimizing for them. Their replacement is going to have to be enough better to overcome those two factors.
Re: (Score:3, Informative)
Funny thing about IFORT is that while in simple tests it always outperforms g77 (I've since switched to gfortran, but haven't tested it too well yet), for complex things (a few thousand lines of FORTRAN 77 using mpi), it is very unpredictable. I have lots of cases where g77 outperforms ifort in real world cases (as real world as astronomy gets anyway) and cases where ifort wins. It just seems to me that either ifort is not the best compiler, or optimizing for x86 is funnier busin
Re: (Score:3, Interesting)
Personally, I'm sorry I w
Re: (Score:2)
Re: (Score:2, Informative)
There are still optimizations possible at the assembly level for each architecture that depend on the quirks and features of those architectures and even their specific implementations.
The intermediate level optimizations are intended to reduce code duplication by allowing optimizations common across all architectures to be applied to a common intermediat
Re:momentum (Score:5, Interesting)
Hard to optimize? You only have to optimize the compiler once, over the millions of devices this cost is small.
This is a red herring anyway. RISC being simpler has nothing to do with it being easier to optimize. If it is easier for a compiler to optimize simple RISC-like instructions, then the compiler can use RISC-like instructions that are present in x86. This has been the situation for years and years. Compilers use a basic subset of x86 that looks a lot like RISC (minus variable instruction lengths), but also with some of the decent syntactic sugar of x86 like push/pop and load-ops (you know: add eax, [esp + 12] to do a load and add in one inst).
The only real obstacle for compilers optimizing x86 is the dearth of registers. With fast l1 caches and stack engine tricks like in Core Duo the performance hit for stack spillover isn't big, and x86-64 basically solves the problem by doubling the register space. Less than a RISC machine, but enough for what research has shown is typically needed. Maybe still a little too few, but combined with the first point enough to make this a wash.
These arguments are as old as RISC itself, but the basis behind them has changed as the technology has changed. All of the performance, efficiency, and other technical arguments have been put to pasture in terms of actual implementations. In the end, it comes down to this:
The only reason not to use x86 is because it is an ugly mess that makes engineers who like elegance cry at night.
The only reason to use x86 is because it runs the vast majority of software on commodity chips.
Which of these factors dominates is not an open question; it has already been decided. It's just those engineers who like elegance can't accept it, and thus keep bringing it up. Believe me, I don't like it either, but I don't see the point at screaming at reality and demanding that it change to suit my aesthetics.
Re: (Score:3, Insightful)
Yes I'm well aware, ever since the Pentium Pro (worst name for a completely new architecture ever). I usually start my "CISC/RISC is an irrelevent argument" rants with that fact. That is exactly why the predictions of the RISC crowd that RISC would blow CISC out of th
Why Apple moved to x86 (Score:5, Informative)
Performance per watt.
The PPC architecture was not improving _at all_ in performance per watt. Apple's market was growing fastest in the portable space, but it was becoming impossible to keep temperatures and power consumption down with PPC processors.
And IBM's future plans for the product line were focusing on the Power series (for high-end servers) and the Core processors (for Xbox 360's) and not on the PowerPCs themselves.
While I've never had any particular love for the x86 instruction sets, I, for one, enjoy the performance of my Macbook Pro Core 2 Duo, and the fact that it doesn't burn my lap off, like a PowerPC G5-based laptop would.
Re:Why Apple moved to x86 (Score:4, Interesting)
Not as I remember. As I remember, the PPW of PowerPC CPUs was pretty good, and getting better thanks to Freescale, but the problem was that Freescale's CPUs didn't have enough raw performance, and IBM's didn't have low enough power consumption. Freescale was committed to the mobile platform and thus was only focusing on PPW, whereas IBM was focusing on the server market, and thus favored performance over low power consumption. Seeing that the situation wasn't likely to improve anytime soon, Apple switched to Intel.
Re:Why Apple moved to x86 (Score:4, Insightful)
I'm confused - didn't you just then go on to confirm that Apple switched to Intel because they got better performance per watt, as the original poster said?
Or do you mean IBM's performance per watt was really good, but had a lower bound on power consumption that was too much for Apple's laptops/iMacs/Mac minis?
I was certainly under the impression that Apple were very frustrated with not being able to produce a 'state of the art' laptop with the G5 chipset (hence this famous image [revmike.us]), and saw the Pentium M and what else Intel had coming, and decided the world of x86 was good. Performance per watt was definitely the reason Jobs gave when he announced the Intel switch.
Re: (Score:3, Interesting)
Having worked there during the mid-to-late 90s, I would characterize the effort more as "overhauling NeXTSTEP into Mac OS X and maintaining an x86 build".
It was a matter of weeks after the acquisition was finalized before NeXT engineers had a PPC build running - minus a lot of support for Apple's ASICs. At the time, Apple's machines were pretty heavily specilaized, w
Re: (Score:3, Insightful)
Dual core 2GHz PPC below 25W isn't an improvement I guess? Look at PA-Semi...
Seriously, this has nothing at all to do with it.. What home user really cares if their PC takes 150W or 180W ? Nobody...
Peter.
Re: (Score:2)
In addition to the fact that some people *do* actually care about the power savings, even if you don't you should still care because most of that power is transformed into heat, which the processor has to somehow get rid of. So you need larger (heavier) heatsinks, CPU coolers etc. not to mention that high power usage often means that increasing the size of the die and/or the clock frequen
Re:Why Apple moved to x86 (Score:5, Insightful)
You mean a processor from a fabless company announced six months after Apple announced the switch to Intel, and wasn't expected to sample until nearly a year after the first Intel Macintosh shipped? It's an interesting product, particularly if the performance of the cores is any good (hard to say, since there seems to be much in the way of benchmarks), but it didn't exist as a product until recently. Even if it had, there's the significant question of whether they could secure the fab capacity to supply a major customer like Apple.
What home user really cares if their PC takes 150W or 180W ? Nobody...
Desktops aren't the dealbreaker here. Try asking "who cares if their laptop runs for 5 hours or 3 hours?" or maybe "who cares if their laptop can be used comfortably in their lap?" or perhaps "who cares if they can get reasonable performance for photo-editing, video-editing and what not in a portable form factor?".
Cast an eye toward the business market and performance per watt on the desktop is important. You may not care about a 30W savings but an a company with 500 seats may well care about 28800kWh in savings per year (assuming 240 work eight hour work days a year after factoring out weekends holidays and vacation).
Server farms and power consumption (Score:3, Interesting)
Re: (Score:3, Insightful)
What home user really cares if their PC takes 150W or 180W ? Nobody...
Anyone using a laptop?
Seriously, the reason for Apple to switch to x86 was due to the fact that Intel has focused their business around creating the best possible chips for laptop computers. Laptops are now more than 50% of Macintoshes sold (and probably more than 50% of personal computers in general).
More money is being spent on R&D for the x86 architecture than anything else and this R&D is focused like a laser on the PC laptop/desktop use case.
There was a time when the best chip available for a
Good question... (Score:5, Informative)
Now I have to wait for the boner this gave me to go away before I can get up and walk around the office.
Maybe Apple could have put off the Switch after all...
Re: (Score:3, Funny)
It's called priapism [wikipedia.org]; you might want mosey on over to the emergency room quickly!
Why do we ... (Score:5, Insightful)
Why do most screws tighten clockwise?
Why do we use a 7 day calender, 60 second minutes, 60 minute hours, and a 24 hour clock like the Sumerians instead of base 10?
Why do we count in base 10 instead of binary, hex, base 12?
Why don't we all switch to Esperanto or some other idealized language?
Or if you're familiar with the story: Why are the Space Shuttle boosters the size they are?
Because sometimes it's easier to stick with a standard.
There. Question answered. Next article please.
Re: (Score:2)
Re: (Score:2)
(I didn't know and had to look it up, myself).
Layne
Re: (Score:3, Informative)
Re: (Score:3, Informative)
from snopes.com [snopes.com]
Re:Why do we count in base 10 instead of binary... (Score:3, Insightful)
That being said, if our ancesters don't use thumbs or used them as carry bits or used them to extend our counting range to 32 we would all be using octal.
But you do use the metric system (Score:3, Informative)
And while you seem to be holding out, I did see one website that suggested less thna 7% of the worlds population doesn't use the metric system
Re:But you do use the metric system (Score:5, Insightful)
I know that a lot of it is simply what you're used to, but Imperial units are nonsensical to me after a science-heavy education using only SI units.
Re: (Score:3, Funny)
if you are gonna compare units, use the commonly used ones vs the craziest version you can find.
In the UK, stone is the standard unit for weight of people, not pounds. If you asked a UKnian how much they weigh in pounds, most of them couldn't tell you (slightly more could probably tell you in kilos), everybody uses stones. 7 stone is slight, 15 stone is heavy. 20 stone is American.
Chicken and Egg (Score:4, Interesting)
Slowly, other architectures became more like PCs: Alpha's got PCI buses, Power Macs got PCI buses, Sun workstations got PCI buses, etc. Eventually, the same happened to the CPUs: the Alpha line was discontinued, Sun started shipping x86-64 systems, and Apple started shipping x86 systems. The reason this happened is that most of the action was in the PC world; other platforms just couldn't keep up, in price and performance.
Not a technical reason (Score:5, Interesting)
The other answer, of course, is that we don't always... ARM/xScale has become *very* widely used, but that is still coming from intel. There are also probably more MIPS processors in people's homes than x86 processors since the cores are embedded in everything.
Re: (Score:2, Interesting)
Re: (Score:2, Informative)
The process advantage means Intel can get a horrible architecture (x86) to perform acceptably at a dece
x86 != Intel (Score:2)
These two things have little to do with one another. Intel isn't the only company making x86 CPUs. It's entirely possible for x86 to stick around while Intel is displaced.
Re: (Score:2)
But that can make a world of difference. Prescott, Nehemiah, Dothan, Crusoe, Venice, Merom and Brisbane are all x86 cores, but they're very different from one another.
x86 is risc for years (Score:2)
Where The Money Is (Score:5, Insightful)
So why the hell do we use x86? A major reason is inertia. The PC is centered around the x86, and there are mountains and mountains of legacy software in use that depend on it. For those of us in the open-source world, it's not to difficult to recompile and maintain a new binary architecture, but for all of the software out there that's only available in binary form, emulation remains the only option. And although binary emulation of x86 is always improving, it remains much slower than native code, even with translation caches. Emulation is, at this point, fine for applications that aren't computationally intensive, but the overhead is such that the clocks-per-instruction and performance-per-watt advantages of better-designed architectures disappears.
A side effect of the enormous inertia behind x86 is that a vast volume of sales goes to Intel and AMD, which in turn funds massive engineering projects to improve x86. All things being equal, the same investment of engineer man-hours would bear more performance fruit on MIPS, SPARC, POWER, ARM, Alpha, or any of a number of other more modern architectures, but because of the huge volumes the x86 manufacturers deal in, they can afford to spend the extra effort improving the x86. Nowadays, x86 has gotten fast enough that there are basically only 2 competing architectures left for general-purpose computing (the embedded space is another matter, though): SPARC and POWER. SPARC, in the form of the Niagra, has a very high-throughput multithreaded processor design great for server work, but it's very lackluster for low-latency and floating-point workloads. POWER has some extremely nice designs powering next-generation consoles (Xenon and the even more impressive Cell), but the Cell in particular is so radically different from a standard processor design that it requires changes in coding practice to really take advantage of it. So, even though the Cell can mop the floor with a Core 2 or an Opteron when fully optimized code is used, it's easier (right now at least) to develop code that uses an x86 well than code which fully utilizes the Cell.
Parent nails it (Score:3, Insightful)
There's no technical advantage to x86. In fact, IBM picked it specifically because it sucked--they didn't want the PC to compete with their professional workstations. Grafted on sets of extensions (SSE, MMX etc) have just made x86 more baroque over the years, and backward compatibility requirements have prevented cleaning away crap like segmented memory.
Howev
68k vs. 8086/8088 (Score:4, Informative)
There were a number of factors that made the IBM team go for the Intel solution rather than the superior 68000 chip from Motorola. One factor was, as you said, the 8088 chip could use plentiful and well-understood 8-bit peripheral chips like the 8251, the 8259 etc. Another factor was that the 68000 had a long gestation -- Motorola had problems producing chips in quantity that could actually run at their specced speed of 8MHz. I played with an early dev board which had a working 68000 but it only ran at 4MHz. At that time the 8086/8088 were already available on the market, in quantity and that's what IBM needed.
The biggest factor though was probably the software. The x86 architecture was structurally similar to the venerable 8080 family's architecture (hence the memory segmentation, 8/16 bit registers etc.), and there was a lot of 8080-family code already out there, including developer toolsets like compilers and assemblers. Intel also released conversion tools for coders to convert existing 8080 code to run on their new 16-bit CPUs. The M68k was radically different structurally from Motorola's 6800 8-bit chips and its instruction set (although a dream to code new stuff for) did not make transitioning older 8-bit code easy.
Re: (Score:3, Interesting)
Ah, no, the 68000 was definitely a single-supply 5 volt chip. It did come in via two pins, though (14 and 49), to spread the current load across the die.
Perhaps you're confusing the power requirements of the chip with the power outputs of the Macintosh power supply which were +5v (main logic), +12v (drive and video power) and -5v (serial).
Color me wrong, but... (Score:2)
I think with virtualization growing, that a future architecture change is almost unavoidable. What we should focus on is developing virtualization to the point where we can switch to RISC or ARM and then run a virtualized system for any x86 based compatibility
The Ugly Architecture Runs Well (Score:5, Informative)
Non x86 architectures are certainly not inherently better clock for clock. That's a matter of specific chip designs more than anything else. The P4 was a fairly fast chip, but miserable clock for clock against a G4. An Athlon however, was much closer to a G4. (Remember kids, not all code takes advantage of SIMD like AltiVec!) And, the G4 wasn't very easy get bring to super high clock rates. The whole argument of architectural elegance no longer applies.
The RISC Revolution started at a time when decoding an ugly architecture like VAX or x86 would require a significant portion of the available chip area. The legacy modes of x86 significantly held back performance because the 8086 and 80286 compatibility areas took up space that could have been used for cache or floating point hardware, or whatever. Then, transistor budgets grew. People stopped manually placing individual transistors, and then they stopped manually fiddling with individual gates for the most part. Chips grew in transistor count to the point where basically, nobody knew what to do with all the extra space. When that happened, x86 instruction decoding became a tiny area of the chip. Removing legacy cruft from x86 really wouldn't have been a significant design win after about P6/K7.
Instead of being a design win, the fixed instruction length of the RISc architectures no longer meant improved performance through simple decoding. They meant that even simple instructions took as much space as average instructions. Really complex instructions weren't allowed, so they had to be implimented as multiple instructions. Something that was one byte on x86 was always exactly 4 bytes on MIPS. Something that was 12 bytes on x86 might be done as four instruction on MIPS, and thus take 16 bytes. So, effective instruction cache sizes and effective instruction fetch bandwidth grew on X86 compared to purer RISC architectures.
At the same time, the gap between compute performance and memory bandwidth on all architectures was widening. Instruction fetch badwidth was irrelevent in the time of the PC XT, because RAM fetches could actually be done in like a single cycle. Less that it takes to get to SRAM on-chip caches today. But, as time went on, memory accesses became more and more costly. So, if a MIPS machine was in a super tight loop that ran in L1 cache, it might be okay. But, it it was just going balls to the wall through sequential instructions, or a loop that was much larger than cache, then it didn't matter how fast it could compute the instructions if it couldn't fetch them quick enough to keep the processor fed. but, X86 absurdly ugly instruction encoding acted like a sort of compression, meaning that a loop was more likely to fit in a particularly sized cache, and that better use of instruction fetch bandwidth was made.
Also, people had software that ran on X86, so they bought 9000 bazillion chips to run it all. The money spent on those 9000 bazillion chips got invested in building better chips. If somebody had the sort of financial resources that Intel had to build a better chip, and they shipped it in that sort of volume, we might well se an extremely competetive desktop SPARC or ARM chip.
Re: (Score:3, Interesting)
This reminds me of an old Dr. Dobb's Journal article that I read more than a decade ago entitled "Personal Supercomputing" (I believe it was back in 1992 or thereabouts) where the author found a good use for a 486+i860 (remember that chip?) combo that involved making the i860 a computation engine and the 486 sort of like an I/O processor, and IIRC it was called PORT. The compiler set for this system didn't generate native i860 or x86 code, but instead compiled C or FORTRAN programs into a type of fixed-len
Limitations of x86 (Score:4, Interesting)
Originally, going to RAM was cheap (in terms of cycles), going to disk was slow, so we loaded what we could in RAM and processed it. However, RAM was VERY expensive, until very recently, having "enough RAM" was rarely affordable. NT took so long to mass market (Win2K sort of, XP did it, almost 10 years), because when NT 3.1 shipped, it wanted 16 MB of RAM on the x86, and 32MB of RAM on the other systems, but going above 8 MB required specialized RAM because the RAM Chips (you plugged chips into sockets then, not chips on cards with standardized interfaces) were mass produced for 1 MB, 4 MB, and 8 MB, but going to 16 MB required using VERY expensive (relative to normal RAM) chips. So upgrading from 4 to 8 was normally doable (usually, they used the same chips, and you filled half the slots for 4MB, I think, it's been a long time since I had a 486 computer), but going to 16MB would often cost $2000 for the new RAM, when computers sold for $2000.
In the days of expensive RAM, the tighter ISA of x86 (more instructions per megabyte) gave them a major advantage in the real world. Sure, the ISA was crap, and the chips were crap, but when the most expensive component was RAM, the x86 used on average half the memory as the RISC competitors, which gave Intel a HUGE advantage in the cost-conscious desktop fight. It wasn't until the last 5 years, when Microsoft stagnated in their quest to use up more and more memory with each release (largely by failing to release OS updates), that the continual growth of RAM outpaced the computers. WinXP will run in 256MB, and run decently on 512MB, but 1GB or 2GB of RAM is reasonable for a decent system, and 512MB is not reasonable for a budget system. However, when we were struggling cost wise with 4MB and 8MB, the larger size of RISC programs was a problem.
Up until this point, it wasn't clear that x86 was the winner, it was the release of Windows 95 on the Pentium chips when Microsoft "won" the market, up until then, Windows was niche, OS/2 looked promising, Apple was a contender, and everyone just ran DOS/WP5.1 and NetWare 2.0. Up until 1995, it was anybody's game.
The biggest hit to the x86 was the lack of registers. In the 8088 and 8086 days, going to RAM wasn't too expensive, and the chip couldn't do much in the mean time, so we didn't care so much that it was the most register starved system. However, as chips got faster, going to RAM got expensive, and we didn't have registers, which is why the x86 GOT SMOKED in tightly run loops, because it couldn't keep enough data in there. The original cache banks (these were high tech, the chips were on a little card you plugged into your motherboard, you could even upgrade them for more) were to run faster than RAM, and created a third tier. Originally, this seemed like a hack because of the lack of registers.
However, our chips have massively increased in speed in the past 10 years (we were running at ~75-200 MHz in 1996) which meant that flooding the processor with data is the problem. The clock cycles are VERY short (we run ~ 2 Ghz, I remember the excitement at AMD making a 12 MHz 286, the 8088 started at 1 or 2 MHz), which means that carrying the signal over the wires is now an issue, so our motherboards are tighter, we keep cache ON THE CHIP, etc.
One reason that the x86 always outperformed was that once going to RAM became expensive, the smaller instruction size (and at the time, having 16-bit integers instead of 32 or 64) meant that if Intel provided 128 KB cache, then the other players needed 256 KB or even 512 KB to have the same caching advantage. This means, all things being equal, RISC was the better architecture, but IN REALITY, x86 could do the same amount of work with half or less resources. This allowed the computers to price cheaper, AND it meant that Intel could make HUGE profits.
For example, if RISC Vendor A sold a solution for $2500, assuming $2000 in parts
What are you on? (Score:5, Insightful)
Do you really believe that? If so, how does one get to this fantasy land you live in? This may be true sometime in the future, but that day is not today.
I happen to own a PowerBook G4. I like it very much. I love nice little purpose-designed chips based on POWER like the Gekko in the GameCube and it's successor in the Wii. But until we're at a point where you can effortlessly and flawlessly run everything from fifteen year old accounting packages to the latest thing to come off the shelf WITHOUT some PHB type knowing any funny business is going on behind the scenes, x86 is here to stay.
Plus, RISC has its own problems. It's not the second coming. It's nice, but not for everyone.
Re: (Score:2)
But to return to the original topic, I'm given to understand that way back in the mid '90s (back when there were a lot of architectures), Intel announced that they were working on their own "next generation" chip which would replace x86 and ultimately hammer everything else into the ground - the Itanium. Back then the x86 wasn't much, and it was easily beaten by Sp
We don't (Score:4, Insightful)
Unfair business practices? (Score:2)
AMD may be a victim, IBM and the PPC chip may also be a victim in all this. Also, the 'Itanic' may be a huge loser of a chip but it served its purpose, it killed off the Alpha (a damn good chip),HP RISC and created FUD about the viability of other RISC chips.
Duh (Score:2)
Speak for yourself (Score:2)
Perhaps more would if Sun supported FreeBSD better.
One reason.. (Score:5, Funny)
Market share and economies of scale (Score:2)
Like it or not, x86 is the portable ISA (Score:5, Interesting)
The x86 ISA hasn't been bound to Intel for some time now. There are currently at least three manufacturers making processors that implement the ISA, and of course there is a vast number of companies making software that runs on that ISA. Not only that, Intel isn't even the source of all of the changes/enhancements in their own ISA -- see AMD64.
With all of that momentum, it's hard to see how any other ISA could make as much practical sense.
And it's not like the ISA actually constrains the processor design much, either. NONE of the current x86 implementations actually execute the x86 instructions directly. x86 is basically a portable bytecode which gets translated by the processor into the RISC-like instruction set that *really* gets executed. You can almost think of x86 as a macro language.
For very small processors, perhaps the additional overhead of translating the x86 instructions into whatever internal microcode will actually be executed isn't acceptable. But in the desktop and even laptop space, modern CPUs pack so many millions of transistors that the cost of the additional translation is trivial, at least in terms of silicon real estate.
From the perspective of performance, that same overhead is a long term advantage because it allows generations of processors from different vendors to decouple the internal architecture from the external instruction set. Since it's not feasible, at least in the closed source world, for every processor generation from every vendor to use a different ISA, coupling the ISA to the internal architecture would constrain the performance improvements that CPU designers could make. Taking a 1% performance hit from the translation (and it's probably not that large) enables chipmakers to stay close to the performance improvement curve suggested by Moore's law[*], without requiring software vendors to support a half dozen ISAs.
In short, x86 may not be the best ISA ever designed from a theoretical standpoint, but it does the job and it provides a well-known standard around which both the software and hardware worlds can build and compete.
It's not going anywhere anytime soon.
[*] Yes, I know Moore's law is about transistor counts, not performance.
CISC (x86) vs RISC (Score:3, Informative)
http://www.heyrick.co.uk/assembler/riscvcisc.html [heyrick.co.uk]
But we did (Score:5, Insightful)
In a nutshell.. (Score:2)
Why do consumers love x86 CPUs (Score:2)
Software vs. Hardware (Score:2)
DOS and Windows MADE the market for the X-86 machines, just as Apple made the market for the Motorola 68000 series. Companies will purchase whatever hardware necessary to run their preferred apps. Almost never will you see an organization purchase part
performance isn't the only factor (Score:5, Insightful)
Cost effective (Score:2)
The reason that we use intel now most general purpose computing is simply is cost effective. Intel based arch. may not be the best in the world but its good enough. There are 20 years of development behind the processor so its well known for what it can do.
There is no reason to go out an develop a proprietary processor when a intel based chip will do off the shelf. The processor wars are over and sadly or not intel won. The have a cheap processor that works for 99.9% of all computing applications.
Th
Because ISA doesn't matter (Score:4, Insightful)
Intel chips haven't really executed x86 since the original Pentium. They translate the instructions into a more convienient form and execute those. They do analysis in hardware and find all sorts of opportunities to make code run faster.
As it turns out, you have to do most of the same analysis to get good performance on a RISC too. So you have a bit of extra decoding work, which you might not have to do on a MIPS or something, but you gain some flexibility in what lies underneath. And if you're producing 10x the amount of processors as Freescale, you're going to be able to make up for any marginal increase in cost the extra complexity costs you.
Also, don't buy into the hype. You can't buy that much from a good ISA on high-end processors. Look at the SPEC numbers for the Core 2 duo vs. anyone else if you don't believe me. IA64 was supposed to be the greatest thing ever because compilers could do all the work at compile time. There's almost every instruction set hook imaginable in IA64. And look how that architecture has turned out.
We use x86 because instruction translation is pretty easy and very effective... the same reason why Java algorithms perform pretty well, Transmeta had a halfway decent chip, Alpha could execute x86 code pretty well, and Apple can run PPC apps pretty well on x86. It's not bad enough to be completely broken, and we can engineer our way out of the problems in the architecture.
Of course, if you're counting transistors and joules, some of this breaks down... that's why ARM and DSPs have been effective at the low end.
Why we REALLY use x86. (Score:3, Interesting)
Because its a better CPU.
Utter nonsense. This is a complete lie. Benchmarks do not bear this out. And this is besides the fact, that this qualifier reveals the PowerPC's primary weakness -- it has a far lower clock rate.
ARM is currently made by Intel. It does have a high ops per clock performance, but it does so at a severe complexity penalty which drammatically limits clock rate. You can't get "free extra shift" or "free conditional computation" without some compromise to the architecture.
Nice in theory. Intel's latest generation compilers put other compilers to shame. Remember that x86s perform a lot of auto-scheduling themselves. While it may seem like putting more scheduling pressure onto the compiler seemed to make sense back in the 90s, no compiler can solve them totally correctly. This is critical especially in dynamic situations such as cache and branch misses (which the compiler can often neither detect or even solve). By letting the CPU solve the problem dynamically as the problems occurr, it can do so nearly optimally all the time.
Are you smoking pot? The state of the art in x86 CPU emulation are the Itanium and TransMeta CPUs. Both failed precisely because of their pathetic performance of their x86 emulators. The x86 has complicated addressing modes, flag registers, structured sub-registers, unaligned memory access, etc, which does not easily translate to "clean RISC" architectures. (However, they do translate to straight forward hardware implementations, as AMD and Intel have proven.)
It is the correct and logical choice. If RISC were really the greatest thing since sliced bread, then PowerPC should be running circles around x86. But the truth is that it can't even keep up.
Why would you want to use a slower, and less functional CPU? Yes, I said *LESS FUNCTIONAL*. Look into how the PowerPC performs atomic lock operations. Its pathetic. Its just built into the basic x86 architecture, but the PowerPC requires significant external hardware support (via special modes in the memory controller) to do the same thing. x86 just supports "locked memory addresses" which nicely maps to the caching modes.
PowerPC is missing both the right instructions and relevant memory semantics to support it directly. PowerPC uses seperate lock instructions for cache lines, which means that each thread can lock out other threads arbitrarily; if you crash or stall with a held lock, all dependent threads deadlock. It also means you can't put multiple locks in a single cache line and expect them to operate ind
As apple proved (Score:3, Interesting)
The reasons for apples switch were made on costing and performance - and undoubtably because IBM failed to deliver.
Of course if something else comes up - I imagine we would see another change.
N.
Maybe you *can* polish a turd? (Score:3, Insightful)
SPARC may well be the same way -- the main issue there is that Sun doesn't have the resources to both build CPU architectures, computer architectures, and OS and application software, and be competitive in all markets.
There are other instances of something similar. Take the Porsche 911. A rear-engined setup (with the majority of the weight of the car *behind* the rear axle) is inherently inferior to a mid-engine design. The car should handle like crap. And early versions, for the most part, did (oversteer was a very real and common issue). Take 40 years of incremental advances in body and suspension design, and the 911 is one of the best handling cars there is. The design is not the best -- it never WILL be the best -- but it is a very, very competent performer. Few things are better.
Flawed assumptions in the question (Score:3, Interesting)
Compilers can also deal with optimization in RISC architectures more easily
This is a dead giveaway that the author is just stabbing at the wind. Scheduling is no more complex with CISC than with RISC. In fact, some compilation can be optimized even better by specialized CISC instructions that happen frequently. This is an ancient debate that is a tie.
With Just-in-Time compilation, legacy x86 programs could be painlessly run on ARM/PPC by translating them dynamically at run time, similar to how CIL and Java work.
Yeah, and run 20x slower.
what do you all think about our choice of primary CPU architecture
The R&D was sunk into x86 by the two most able teams, Intel and AMD. Companies are driven by profit, and higher profit meant honing x86 and leveraging an installed base. That's the only reason why we are x86 world.
But claiming a RISC world would be better is again an argument that has been put to rest decades ago: we'd be having the same argument reversed if RISC was the dominant architecture.
Further, there are pedants out there who will argue all x86 is really RISC under the hood, but that's a bit misleading.
Who cares? (Score:3, Insightful)
So, we'll keep using x86 in this market because it's what we've been using. We need *some* ISA, and now that the ISA itself is largely decoupled from the underlying implementation, there's very little incentive to change it.
Because They're Good Enough (Score:3, Insightful)
To elaoborate: I used to have and Amiga with an '040, and I remember then the arguments about how it was a "better" processor. But when the Commodore died I got a Cyrix Pentium-class PC and it seemed faster rendering in Lightwave, and that was all I really cared about at the time. Years later I switched to the Mac because I liked OSX. I ran it on a G4, and everyone said the G4 was "better" than the x86 of the day. I'm on a MacBook Pro now, with a Core Duo, and it seems faster. At least as fast, if not faster, than my wife's G5. Battery life is about as good as my G4 was. Maybe it gets a little hotter, but I don't really notice.
So in the end, regardless of any aesthetic concerns about the architecture or theories about what is "right", "clean" or "better", x86 seems to have been good enough all along the way to make switching a waste of time. So if it's not pragmatically better, why all the sorrow?
Cheers.
Re: (Score:2)
Actually, my guess is it's because they don't know any better.
Most CEO Joes are probably more likely to remember the cost of their latest laptop instead of the processor speed, memory size or HD capacity. So in some cases they would like to use it to brag about their 3K USD laptop. But aside from that the same guy who can't tell you if he has a P3 or P4 under
Re: (Score:2)
I know of a few people who recently bought Macs because Apple switched to Intel based processors, and because Apple was smart enough to realize why most people were buying Windows PCs rather than Macs; people buy Windows based PCs because they believe that it would be expensive to replace their software library by switching operating systems (I say believe because 90% of software you own will likely be upgraded before you use it again, meaning you'd
Re:Code Size is the answer (Score:4, Interesting)
RISC CPUs with 4-byte instructions that don't do very much require lots of memory bandwidth to execute.
Well, I'm currently working on ARM, and stuff almost always ends up smaller than x86 code. Those 4-byte instructions actually do quite a lot. Oh, and that's with straight ARM code, not Thumb or Thumb-2.
The x86 instruction set has lots of 1-byte instructions
Not so many actually, and the ones it does have are mostly totally useless these days!
and multi-byte instructions that do a lot.
Well, you get to do fancy addressing modes on the rare occasions that you need them... But not too fancy, no pre/post increment/decrement etc.
In other words, x86 is really just a compression scheme for instruction sets.
Sort of, except that it was never designed to be one, and it's not very good at it at all.
Well, you could say that it was an OK (but not great) encoding for 8086, but it's totally unsuited to encoding the instructions that modern software actually uses.
Re: (Score:3, Insightful)
Yes, really. But there are many variables, of course.
Increment/decrement of a register is one of those 1-byte instructions.
Yes, and push/pop. Note that I said 'mostly', and that my general point is that such instructions take up too much opcode space for their relative usefulness.
And don't underestimate those fancy instructions. It's very nice to be able to do things like a nondestructive multiply by 5 without using up the ALU.
It's nice, occasionally, but you don't n
Re: (Score:3, Informative)
Increment/decrement of a register is gone in 64 bit code and painfully slow anyway (it seemed a good idea in 1977, but partial condition code register updates are a pain). Lots of floating point instructions have three or four bytes in prefixes alone, that's before we even start with