Slashdot Mirror
Why Do We Use x86 CPUs?
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?
Until someone replaces the PC.
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.
tasks(723) drafts(105) languages(484) examples(29106)
because they don't cost an ARM and a leg and they don't pose as much of a RISC
Change is expensive.
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
The reason given, which people seem to keep forgetting, was pretty simple and believable:
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.
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...
hang brain.
Why do we drive on the right side of the road in some places, left in others?
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.
The world is made by those who show up for the job.
I think it's a chicken and egg proposition. We use x86, because we use it. Historically, this is because of the popularity of the PC. A lot of people bought them. A lot of software was written for them. Other architectures did not succeed to displace the PC, because of the reluctance of people to abandon their software. Now, with years and years of this happening, the PC has actually become the most performant platform in its price class, while simultaneously becoming powerful enough that it could rival Real computers.
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.
Please correct me if I got my facts wrong.
Gotta hand it to Jobs ability to spread bullshit, but no one honestly believes the damage control story that Apple ever wanted to land in x86 land.
After years of chip order games and being an all around pain in the ass to work with company, IBM, having recently locked up all three major console manufacturers, decided Apple was no longer worth the measly four percent of their chip business for the major hassle it was to deal with them. So IBM decided to dump Apple as a customer and not make a mobile version of the G5.
Jobs in a panic ran to PA Semi to bail Apple out and was turned away.
And AMD didn't have the capacity to sell to Apple.
So Apple was left with only Intel - as their 'first choice'
Bravo Jobs!
The same reason we use Windows.
It's not that we are particularly in love with either, but because they represent the well-trod path. Speaking for myself, I take some small comfort from knowing that my problem may already have been someone else's problem, and that the answer may very well therefore be available with a little research.
Having (privately) purchased AMD processors for the past 5 years or so, I have recently switched back to Intel -- sorry, Mr Dell -- but wish AMD and others a long and healthy life to keep both development and pricing competitive!
The reason is that intel provides better infrastructure and services that any other high performance microprocessor vendor in the industry. When Motorola or IBM tried to make a sale, intel would swoop in and offer to develop the customer's entire board for them. The variety of intel reference designs is unmatched. Intel not only provides every chip you need for a full solution, but they do it for more possible solution sets than you can imagine. Intel will manufacture your entire product including chassis and bezel. Nobody even comes close to intel's infrastructure services. That is why even when other vendors have had superior processors for periods of time over the years, intel has held on to market leadership. There may be other reasons too, but there don't have to be. That one alone is sufficient.
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.
``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? ''
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.
Please correct me if I got my facts wrong.
internally, it is. and with the modern cpus the ipc is better than with powerpc.
Conservatism: The fear that somewhere, somehow, someone you think is your inferior is being treated as your equal.
#1 - Power architecture got more performance per clock? Fine. IBM couldn't get it to ramp up clockspeed though, so it couldn't keep up with higher-clocked Intels that were still faster in genuine terms. That's why Apple dumped them in the first place.
#2 - Just-in-time x86 emulation... ahh, you mean Itanic! We all remember how well THAT little experiment on Intel's part went over; you had a processor of 1.5+ Ghz that ran x86 apps about as well as a 386sx processor.
#3 - Compilers deal in RISC more easily because the instruction set is less... but it takes you more instructions (and more clock cycles) to get the same operation done if the instruction isn't in the set. See also Cache Misses and performance degradation. RISC architecture is fine when you can accurately predict what the most-used instructions are and be sure they will be included, but if you miss one, performance hurts. Sure, in a single-case scenario like a PDA, RISC might work well, but on the scale of a desktop, you never know when someone will come up with a program that uses a heck of a lot of instructions that aren't in your RISC set, and that's where CISC will blow your little RISC chip out of the water.
Side note: this is why the major gaming platforms use the PPC architecture; because when you're writing games, the vast majority of programming options are known quantities and you can just make sure they are in your instruction set.
#4 - BACKWARDS COMPATIBILITY. I recognize you tried to include this with your quip about just-in-time compilation, but no emulation or alternative compilation is ever flawless (as Microsoft is discovering the hard way and emulation programmers have known for years). If you're running similar architecture, you've got a better chance of older programs still working.
If you can read this sig, congratulations, you have your glasses on!
In order to run lots of instructions per second you must have the memory bandwidth to move those instructions from main memory into L1 cache. You must also the memory bandwidth for whatever processing you're doing. Because of this Von Neumann bottleneck, your program must compete with your data for memory bandwidth. As it turns out, there is also a disk bottleneck. Every 4k page of code has to come from a disk which requires a few ms to seek and read the data. Thus, your program will run faster if it is compiled for x86 because it requires half as many disk seeks when it's demand-paged in.
RISC CPUs with 4-byte instructions that don't do very much require lots of memory bandwidth to execute. The x86 instruction set has lots of 1-byte instructions and multi-byte instructions that do a lot. In other words, x86 is really just a compression scheme for instruction sets.
Modern x86 CPUs take the instruction stream and convert it into RISC-like chunks that actually get executed, so moving to x86 isn't a move away from RISC, it's a move away from verbose instruction encoding.
dom
There's no doubt that x86 is an ugly, hacked-together architecture whose life has been extended far beyond reason by various extensions which were hobbled by having to maintain backwards compatibility. x86 was designed nearly 30 years ago as an entry level processor for the technology of the day. It was originally built as a 16-bit architecture, then extended to 32-bit, and recently 64-bit (compare to PowerPC, designed for 64-bit and, for the earlier models, scaled back to 32-bit with forward-looking design features). Even the major x86 hardware vendors, Intel and AMD, have long since stopped implementing x86 in hardware, choosing instead to design decoders which rapidly translate x86 instructions to the native RISC instruction set used by the cores.
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.
Anonymous Luddite: "What do you think of the dehumanizing effects of the Internet?"
Andy Grove: "Not Much."
If I remember right, weren't some Cyrix processors based on RISC architecture using a solid-state translation system a while ago? Whoever it was, I remember that already happening but the translation made it about half the speed of competing systems.
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.
Erutangis ym si siht.
<sarcasm>
Why bother with all the trouble of teaching your compiler to optimize with register coloring when you can just have a processor that has a couple registers and does the register renaming for you! And everyone knows that more instructions make a more powerful processor. To say nothing of the quantum leap that is stack-based floating point math, because there's nothing more powerful than an HP calculator.
And little endian... it's so great! In C, if you have unsigned x and you want to put the bottom 8 bits into unsigned char y, both y = (unsigned char)x; and y = *(unsigned char*)&x; result in the same, minimal code! (As compared with big-endian, where pointer math must be done in at least the latter case, wasting precious cycles!) One of these days, Motorola, the Internet, and the Arabic number system will understand the foolishness of putting most-significant digits first in numbers.
</sarcasm>
Seriously, though, it's just inertia. Most people don't like to reinvent wheels. Nothing more.
I'm just getting old, and sick of seeing the worst available solutions to problems getting standardized.
Dynamic translation through JIT optimisation isn't really that efficient for the general case, at least from an x86 source*.
To see a good example of this, look at Transmeta Crusoe, which appeared to be an x86-compatible device, but was actually a 2-issue VLIW core running a software x86 emulator with a JIT compiler. Crusoe was really efficient at benchmarks, but its performance for "real world" applications was not so good. The simplest methods of optimisation - cache, branch prediction table, superscalar issue unit - seem to be more effective than complex optimisations involving recompilation.
In Crusoe, the processor was specifically designed to operate by dynamic translation. It had hardware support for some things, like undo-ing speculatively executed instructions. If you pick a random ARM or PPC processor as your target, you don't get this, so performance will be even worse.
If your source language isn't x86 code, you can clearly do more. If, for example, your source is written in C, you can do as much as an ordinary compiler. If your source is an intermediate register-transfer language, you can do almost as much. But x86 code doesn't provide much information to facilitate recompilation.
* disclaimer: my PhD is in this subject area but I've not finished it yet.
There are no non x86 companies that can afford the required investment to develop and mass produce a suitably competitive architecture at a reasonable unit price. I guess the one exception to this is POWER, the last of the remaining high performance RISC architectures. It is a big risk to launch a completely new architecture that no one may want to buy, unless that architecture will offer massive improvements over anything that currently exists. Intel should remember this, and start making Itaniums on a current production process, or soon desktop chips will be sporting enough cache, and will be able to address enough memory to make Itanium irrelevant (in my experience, the only programs that perform better on Itanium are those that utilise massive amounts of cache effectively)
x86 is not so bad these days. The AMD64 extensions negate some of the traditional problems (lack of registers), and the modern FP instructions are somewhat better than the original crappy FPU, and the variable length instructions often act as a crude hardware compression scheme for code being read across the bus.
Incidentally, the instruction set for RISC chips is not necessarily 'smaller'. It is is however more regular, and it is easier to choose the correct instruction sequence for a particular purpose.
One perspective on the question:
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.
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.
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.
Maxim: People cannot follow directions.
Increases in truth directly with the length of time spent explaining them
We don't really use x86 CPUs, they're all RISC with an x86->RISC decode stage at the front of the pipeline. As far as I understand it, we use the x86 ISA because there has always been too much x86 specific code around for people to switch easily, which gave Intel huge amounts of money to spend on research and fabs.
If you google 'Intel Busness Practices' you will find a number of probes into Intel, its monopoly status, using that monopoly status to keep competitors down, dumping chips to depress prices for competitors, locking AMD out by restrictive licensing etc.
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. The 'Itanic' will probably eventually go down, but Intel will still win.
You can argue specs and technical merits as much as you want. But the real reason Intel dominates is more to a business model than to technical merits. Which is pretty common in IT in general, software as well as hardware.
putting the 'B' in LGBTQ+
Because all our favorite programs run on x86, and not on whatever other alternative we would choose otherwise. And then we make more programs for x86, ensuring we will continue to use it.
Perhaps more would if Sun supported FreeBSD better.
Sent from my ASR33 using ASCII
tIs' ebacsue ilttel neidna si ebttre.
-- MartinG To mail me: echo kewyjlcxyzvjfxbqwh | tr bcefhjklqvwxyz
The reason x86 is better is because its more popular and therefore Intel and AMD have more money to pour into R&D than anyone else. Or I would probably even say everyone else combined. So they make better chips, which sell more and the cycle continues. The other reason is that most PC software currently used is non-Free and runs on Windows and windows runs on x86. Obviously here we are only talking about PCs. Embedded is a completely different story where x86 is marginal, but the performance requirements are completely different and most of the time much lower or very specialised.
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.
Note to ACs: I usually delete AC replies without reading them. If you want to talk to me, log in.
The reason that we use the x86 at all is because that is what IBM used for the PC. Prior to the PC, there were lots of different computers using many different chips. The PC was, in a sense, open source because IBM published the Technical Reference. That made it possible for anyone to build plug-in boards, and not long after, clones. All the other computers disappeared fairly quickly. Apple had been burned by Apple II clones. They prevented that from happening with the Mac. If they hadn't been so successful, we might all be using 68xxx chips.
Microsoft runs on x86 and they haven't seen any reason to diverge. Just as IBM had become the de facto standard, Microsoft is now the de facto standard. Things probably won't change while that is the case. We should also note that a few years ago there were different chips used in servers. The alpha comes to mind. Those have pretty much disappeared because x86 performance has increased to the point where the other chips provide no advantage and x86 is a lot cheaper.
Given that Linux can be made to run on just about anything from small embedded systems to supercomputers, there's nothing technical that prevents one from using a non-x86 cpu. Given that our computers are becoming very power hungry, it seems reasonable that someone will come up with a better architecture. The basic technology has to change to make that likely though. A cpu chip and memory that natively communicate optically might be such a change. It would be a chance for everything to start fresh because much of the old infrastructure would be obsoleted and there would be no reason to stick with it.
People want computers to compensate for their lack of dick size, hence PHB executives buying powerful notebooks to play solitaire and use MS Office
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 the hood of his ThinkPad probably isn't going to understand that a 350-P2 is going to run Office just as well as his new Intel Duo 2 rig.
As for dick size? That's what the car is all about. Most CEO Joes understand all the base stats about their car. They understand what a 5 litre engine is, they know the impression bullshit like trailer hitches and fog lamps leave on others as they cruise along in their Navigator. They know that people are going to be more impressed by a 120K USD Humvee over a 3K USD laptop.
The only people who really think that people are impressed by their laptop are geeks and wanna-bes (wanna-bes moreso).
Dedicated Cthulhu Cultist since 4523 BC.
Obligatory wiki page
.. and the US is 80% of that 7%
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
I am Slashdot. Are you Slashdot as well?
These days there is a limited amount difference under the hood between a CISC processor like the x86 series and a RISC processor. They're mostly RISC under the hood but a CPU like the x86 has a layer of microcode embedded in the processor which implements the complex instructions.
http://www.heyrick.co.uk/assembler/riscvcisc.html
Moderating "-1, Disagree" is simple censorship. Have the guts to post your opinion.
vote with our wallets. The x86 architecture was cheaper than ppc, so that's what consumers chose. It is still consistently cheaper than other architectures. That's ultimately why Apple is moving to it too; they weren't selling enough product (yes, not being able to put their best chip in their laptops hurt, but most people were saying why am I paying $1000 more for a Mac when I can get almost everything I want from a PC)?
Well, that's what Transmeta thought. They even had special-purpose hardware to assist the software in the translation. It didn't work for them. It appears that dedicated hardware translating x86 into whatever internal instruction set the processor uses is the way to go (it's what Intel does since the Pentium Pro and AMD since they bought NexGen, for instance).
Because IBM chose x86 instead of RISC.
We use x86 CPUs because they're cheap, versatile, and run all of our old software. All of the little things the OP complains about might matter to a seriously nerdy programmer, but to 99% of the people using computers, those words are just gibberish. Something else to keep in mind about non-x86 CPUs is that yes, they may be faster than x86 at task X or cheaper for task Z, but that's because most of them aren't really designed for general use; if they were used by everybody, the architectures would change to reflect that, and those chips would quickly become less nerd-friendly.
The magic number isn't "performance per clock" or "performance per watt" but "performance per unit of time spent writing the program".
x86 is still with us because its architecture fits the way that humans write code.
Its because Bill Gates mom was in the Unitedway board with the guy responcible for the IBM PC. I though everyone knew that!
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 particular software just so that can use a particular Hardware platform. That died out after the Notes on Unix experience.
Why don't we all drive Formula 1 Cars? Why not hybrids? Why not motorcycles or electric scooters? The reason is that there is an infrastructure built around supporting a platform that is reliable, robust, and surprisingly extensible. (MMX, SSE, 64bit, etc) Intel asked the same question and came up with the Itanium. It is fast, efficient, and well understood. This is the same big reason that people don't use Linux, it's hard to switch for minimal tangible benefits. (not a flame, just an observation)
People who think they know everything really piss off those of us that actually do.
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.
This doesn't mean that the proprietary are completely dead. There are some areas where a general purpose x86 isn't a good fit. The processor in a pda or a cell phone would be a good example. But for general purpose computing the x86 design is good enough.
Supporting World Peace Through Nuclear Pacification
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...
This is the old argument about RISC vs CISC. The very first thing to ask is better performance per clock how? When a RISC architecture is implemented to do simple things on every clock in order to be able to perform at much higher clock rates, then you end up using more clocks to do anything useful. In addition, you pay a penalty in memory efficiency because many more instructions (all doing simple little things) are required to do things that CISC processors can do in one or two instructions. More instructions in a CISC architecture lead to larger cache sizes to be able to contain typical loops, thereby negating some of the power efficiencies you speak of. Fully half of the power expended in modern processors is burned by the cache, not the actual CPU.
The only RISC architectures that actually managed decent performance used all the tricks in the book: pipelines, predictive branching, caching, etc. Do any of these things sound familiar? They are all things that give the present x86 architecture its performance. By the time you add all these things to a RISC architecture to gain performance, then a CISC architecture beacomes viable again because of memory density tradeoffs, cache sizing and power dissipation. There aren't any real simple answers.
OK, parent is the first post I've seen that explains the real reason why the x86 has become basically the only instruction set in mainstream computing.
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.
However, once a big enough chunk of the market got behind x86, it became impossible for any other design to keep up in R&D across all segments (mobile, desktop, server etc). Intel collects truckloads of cash, so they can spend more on engineering and make up for x86's deficiencies. IBM can compete with Intel, but even IBM decided it wasn't financially viable to be competitive in all segments, and basically dropped desktop PowerPC to focus on embedded (game consoles) and servers, hence Apple's switch to Intel. Similarly, AMD can compete, but only in desktop and servers. VIA compete, but only in embedded and low-end desktop.
The interesting question is whether the same thing will happen with operating systems. We're now basically down to Windows and Unix, plus a few niche OSs for embedded systems and high end servers. Microsoft finds itself in the awkward position of having to compete against most of the rest of the computing industry, including Sun, IBM, Apple, HP... At the same time they have certainly the biggest--and likely the cruftiest--codebase in the history of computing.
Ten years ago they were able to deliver technology before the competition, albeit not original technology--DDE and OLE shipped in usable form before the Publish-and-subscribe and OpenDoc they were copied from. Now things are different, Microsoft is struggling to keep up with Apple. It seems they can't copy Apple's new technology as fast as Apple can invent more new stuff. And at the same time, they're trying to fight two more wars in the embedded space with Xbox and Windows CE. Hence 5 years between desktop OS releases, while Apple has a release every 18 months.
GCHQ Quantum Insert installed. If only our tongues were made of glass, how much more careful we would be when we speak
I was asking myself that very same question for several years now...
:-/
Assembler-wise, I know ARMv5, Motorola 68k and Intel x86. Compared to the former two, x86 is not just plain ugly, it's just primitive and dumb. For example, since there are no real all-purpose registers (every register is eventually required by some instruction to be used in a special way), you always have to use the stack or memory. Using the stack is now quite efficient and cached by the CPU, AFAIK, I don't think it's a match to having a few all-purpose registers.
And the legacy of the 8086 (which was a hack to get to market quickly with a 16-bit processor) and then the 80386 are still with us, and I'm pretty sure todays processors could be faster and/or more efficient if things would have been designed better back then. Even Intel seems to think it's a bad design and AFAIK tried to replace it several times (iAPX 432, maybe i960, Itanium), but they failed horribly because those CPUs were too slow or too late (market penetration of the x86 was too huge then).
Oh well, there's a saying: "Programming is like sex: one mistake and you have to support it for the rest of your life". Same is true for hardware, it seems. That's why we still have this 1980'ish BIOS and boot process and other stuff that were mistakes from day one.
The reason why they're still here is that back then, the solution wasn't so horrible and only meant to stay for a few years, not decades. If people at Intel and IBM would have known that their stuff would stick with us for this long, they would have done a lot of things differently, I'm sure. But to everyones surprise the 8086 and IBM PC were big successes, and once you've got a certain market penetration you can survive even when there are better alternatives... history has shown this several times already
Why do we use VHS when it is understood that beta is a better technology?
Marketing.
The herding instinct. We go with the flow.
IP law. And PPC isn't the only superior tech being locked down. The Alpha chip rots on the shelf while we clunk along in our model Ts. *sigh* Let's hope this "electronic paper" thing can kill off the hardware monopolies.
What?
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.
-- Erich
Slashdot reader since 1997
"Voting with your wallet" for PowerPC meant implicitly choosing Apple hardware, Mac OS and the option to install Linux. That was/is not the mainstream choice... seems to me that the prevalence of the Intel x86 architecture has more to do with the fact that Windows runs on on Intel.
Over 10 years ago, Microsoft supported PPC, ALPHA, and MIPS in NT 3.5.1 and early versions of NT 4.0. I remember a COMDEX where NEC was showing off dual-CPU MIPS boxes that were running NT 4 and running circles around the fastest x86 at the time. About the same time, the IBM/Apple/Motorola PPC tent was the first thing you saw coming into the show and it was to be the NEXT BIG THING (even saw one of the two 500 MHz PPC in existance, when the fastest x86 was about 100MHz).
However, if you wanted to get a PPC to play with, it was quite expensive and not readily available. IMHO, it was always more expensive than an inexpensive PC. Apple was the only reasonably-priced PPC (and even then it was at a premium over x86 for similar capabilities). We had an Alpha that we ran an early 64-bit Linux on (RH 4 or such), but it was just a test machine (too expensive, too hard to use as no standard BIOS, limited, and not the customer's standard -- which is now DELL).
When MS decided to stop supporting NT on other architectures (including anything 64-bit....), about 10% of NT was supposedly on MIPS in Asia. They basically killed any chance for non-x86 architecture in the mainstream other than embedded, server, or engineering applications. The kill off of non-x86 was a marketing decision by MS and most likely saved them a bundle in R&D, hence contributing to the bottom line, while not having much of a long-term impact on the market (those using non-x86 NT HAD to migrate, adding more sales for both Intel and MS).
Architecture is meaningless for the end user and almost meaningless for the application developer. The preferences of OS designers and compiler writers are meaningless unless it can somehow Make Things Better for the end user.
IIRC, Dec Alpha, The Sparc, PPC, and x86 were all supported by WinNT. No one bought WinNT for anything other than x86, however.
Best Slashdot Co
There are lots of posts already outlining the technical aspects of why (Speed/Power/Momentum/whatever), and while they are certainly important, I think it misses the crux entirely.
x86 is dominant, because Microsoft Windows has a monopoly on the desktop computer market, with an operating system that runs on x86. Intel and Microsoft have massive synergies - Intel gets dominance of the CPU market because it has Microsoft Windows, and so it can spend massive amounts of R&D and win the speed/power/technical merit wars (sometimes, or enough), and this massive amount of CPU power allows Microsoft to bring us amazing breakthroughs like the Aero interface (and the new Office ribbon!)...
Why Microsoft got that monopoly, and why it does/doesn't deserve to keep it, gives us endless comments on slashdot already, so no real point in going in to it here.
(Yes, I'm aware there has been Windows for other architectures, but the massive backlog of x86 software that runs on Windows and won't be recompiled for something else is HUGELY important)
--Q
They're the real reason why we stick with x86. Should Microsoft release an ARM9 or PPC version of Windows, vendors will recompile their apps and games for the new arches and suddenly x86 will look too expensive. And no WindowsCE does not count.
As for Intel, they'll stay in the market. They are already owners of one of the best ARM (or almost ARM) implementations. Their strength lies in the system-on-chip design experience and the most bleeding edge fabs. They're by no means tied to x86.
Blame it on Microsoft.
"Give orange me give eat orange me eat orange give me eat orange give me you." -Nim Chimpsky
The Power architecture was known for its better performance per clock
Performance per clock is not as practical as actual performance. The problem, which has been rehashed endlessly in the better PC vs Mac debates of old, is that the x86 of old had far more clocks and more than made up for the PowerPC's efficiency. More recently x86 became better performing per clock, so it is a moot point.
FWIW, I am not slamming PowerPC. I believe Motorola and IBM took some unfair criticism with respect to PowerPC performance. While PowerPC may not have progressed as fast as expected, the real reason for the x86/PowerPC gap was that x86 progressed far more than anyone ever imagined. Intel and AMD are miracle workers.
I'm very happy with my Powerbook G4 as primary desktop and a dual cpu Alpha as a server. Sure I use x86 from time to time, but I can name at least 3 architectures I use more.
In order to change the X86 market you'd need a revolutionary processor that's so fast and efficient it would make the current X86 processors obsolete. On top of that, in order to attract software companies you would probably need to be able to run existing software at better than native speed. This means you need a radically new idea in the design and material. Also in order to produce the product you'd need a shit load of funding to build it and market it. The risk is so great, it makes the event highly unlikely.
The only processors I've heard of that might lead to this revolution are the light processors. I haven't heard much from those camps in a long time, they were still playing with nanotube switches.
If Apple's problem with PowerPC was Performance Per Watt, then why'd they switch to Intel instead of AMD?
Signatures are a waste of bandwi (buffering...)
When will the need for parallel processing outweigh the need x86.
I've been feeling lately that clock speeds have plateaued. Both my last two laptops have had 2Ghz chips, granted i've moved from a Pentium M to a Core Duo, but we're seeing faster systems without spiraling clock rates.
I'm not sure whether it's the PC architecture or the x86 instruction set, but it seems like we rarely see PCs with more than 4 cores.
Other architectures are moving fast. I've got a 200MHz OMAP in my cellphone and they are replacing that model with a 400MHz one soon. I'm certain high end PDAs will outspec low end laptops in the next few years, which will open up a lot more architecture choices for everyone.
...just not looking closely enough and where there is a huge interest in a pc device for media and games (think about every household on the planet now that can afford media playback and does gaming), and that is the CELL processor that is now going into millions of non standard but powerful and widely used computers, even though they aren't sold that way directly. That market is just going to get bigger and bigger, and there will be more and more effort to port more applications that will run on it. Think about what most people use a computer for, and the CELL would work quite well. There is a rough 10% of specialist and business apps that might not work, but the CELL is or will be shortly going into everything from supercomputers to the cheapest game consoles. Add in a few more specialty chips on a mobo with a cell and you got a good overall PC.
The reason that we use the x86 is because IBM used it for the PC. The PC supplanted almost all the other computers on the market. One reason was that it was easy to build cheap clones. Within a few years the majority of x86 based PCs were not built by IBM.
Apple had the first mover advantage though. If Apple had not made it difficult/impossible to clone the Mac then it is likely that the Mac would have been the de facto standard by the time IBM decided to build the PC. IBM 'open sourced' the PC's design so they would not have to create everything in-house. It seems likely that, if there was a lot of Mac based stuff on the market, IBM would not have selected the x86.
Capiche?
seggus Ipu uoy toy edargib 61 ruetsys st 46 ot m P: stib
I have discovered a truly marvelous proof of killer sig, which this margin is too narrow to contain.
(although, I hear Franklin Mint is coming out with an Intel vs. Motorola "CPU Civil War" set).
"Prepare for the worst - hope for the best."
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.
I want to drag this out as long as possible. Bring me my protractor.
From the Because-They're-Cheap Department.
:)
Too cheap to proofread?
If you look at the actual instructions generated by modern compilers for x86-64, it is much more RISC-like than ever. It uses a flat (non-segmented) 64-bit memory space and the sane set of x86 instructions in practice. Sure, the chips have to support all the seldom-used instructions, but that is done mostly via microcode. In addition, x86-64 has 16 registers (rather than 8), reducing the frequency of memory operations. The new function call ABI for x86-64 also allows passing values in registers (and not on the stack in memory), further reducing needless memory instructions. Finally, x86's variable length instructions actually reduces the size of the program, improving instruction cache performance over a RISC ISA with fixed-size instructions (like PowerPC). It turns out that when you have a billion transistors to play with, the exact ISA just doesn't matter as much as the quality of the specific design. In summary, x86 is ugly, but doesn't really impact the performance and power as much as one expect.
Stop thinking in terms of nerdboy novelty and think in terms of how it affects your mom. I call this The Mom Factor. Mom doesn't care about programming (assuming she's not a programmer). Mom doesn't care that it's a 3.2GHz processor with DDR2 800 RAM instead of DDR2 600. 99% of computer users are like proto-Mom. They really would care more about the color of the box instead of what's inside. Why should they care what's inside?
The ultimate in usability for computers is a box that magically works when plugged in. Green button that says "GO" optional.
Intel make AMD compatible 64-bit CPUs!
Those of us who have observed the industry for decades have gotta love that.
${YEAR+1} is going to be the year of Linux on the desktop!
CIL performs static transformation on source code during compilation, not a dynamic transformation at runtime or a just-in-time compilation. See the documentation at http://manju.cs.berkeley.edu/cil/ for more information. Also, Java uses a virtual machine to run code compiled specifically for the VM. You might instead refer to Apple's Rosetta runtime translation from PPC instructions to x86.
Apple didn't just decide in 2005 to switch to Intel. Apple had kept Intel builds of OS X going since before OS X came out in 2001. If Apple were going to switch *away* from the PowerPC, Intel was really the only choice (since the port had been kept alive); starting anew with a port to Niagara or any other architecture would have cost years.
-- "Those who cast the votes decide nothing. Those who count the votes decide everything." -Joseph Stalin
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
Probably the reason for this is that there just isn't that much real-world performance to be gained by playing around with the user-visible view of the instruction architecture, which right now is an implementation detail that occupies a tiny corner of the die.
If you do anything other than x86 Linux you'll hit onto various speed bumps, i.e. applications not working quite like they should. If you're willing to deal with those little annoyances - great for you, but most prefer to get an IA-32 box and call it a day. The reason for this is because various Instruction Set Architectures have subtle differences that an application can become dependent on. There's memory alignment, byte order, 32/64-Bit and various other oddities creating bugs that can be tricky, to say the least, to track down.
The legacy of x86 software cannot be underestimated. Frankly I don't care anymore what the performance characteristics of a CPU are as long as it runs the software I want. Which in the past has meant me being able to readily download free software such as WinAmp (among lots of others) without hassle. I really do not care if it is PowerPC, MIPS, Alpha, etc. However the inability of these platforms to readily execute the x86 instruction set is precisely why people never purchased these systems when Windows NT used to be offered on them. No shock various vendors pulled out and ultimately Microsoft withdrew OS support of these processor architectures.
There used to be a day I had interest in this subject matter, not anymore. Just let me do the things I want to do, browse, listen to music, play games. I want to do these things without being encumbered or giving a rat's a** about instruction pipelines, branch prediction or how ueber a processor is because it has X more registers than the legacy x86 architecture.
AMD understood this all too well when they spearheaded the x86 platform to the 64 bit front... much to the chagrin of Intel with its "Itanic" architecture... with Intel ultimately following suite transitioning their x86 product line to 64 bit.
-M
PS: "Just because it's difficult doesn't mean it has value." --Yours truly
I think this is a lot like the question, "Why do we drive gasoline cars?" or, "Why do we use IPv4?"
There's just a ton of infrastructure built on x86/gas/IPv4, and even though there are alternatives that are arguably better, the infrastructure just isn't there.
---
This post encrypted in ROT-26. Any attempts to read this post are in violation of the DMCA.
by keeping their code open (at least internally) and cross platform it really doesnt matter what architecture it is running on. The switch to intel was comparitively quick - relatively speaking.
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.
Electronic Music Made Using Linux http://soundcloud.com/polyp
Just what I always needed! No wait, I'll rather take a top of the line Core Duo any day.
Other processor architectures dominate industry and the home. PowerPC is the dominate architecture for game consoles (PS3, Wii, Xbox360). Home firewall appliances are usually PowerPC or MIPS. Higher end cell phones are ARM. iPods are ARM (I believe). DVD Players can be anything from SH-3 to MIPS to PowerPC.
While an average household might only have two x86 PCs. You can turn up lots of ARMs and a few PowerPCs in a typical household. Pretty much all modern cars have a computer (ECU), and PowerPC is a popular choice for these devices. Motorola makes some extended temperature range models of their MPC series (PowerPC) microcontrollers.
“Common sense is not so common.” — Voltaire
There have been quite a few comments that Intel wants x86. Actually that is AMD's position because they only sell x86. Intel promotes IA (Intel Architechture) which goes beyond just x86. If you reach way back and remember that Intel did try to move away from x86 when they introduced IA64. However they were trumped by the marketing of AMD and Microsoft's choice to develop Windows 64 for AMD 64. And if you don't believe the marketing claim, how many of you actually bought a 64 bit processor to future proof your system only to replace it before ever actually installing a 64 bit operating system?
Intel could develop whatever architechture it wants (that isn't licensed by another company) but they keep cranking out the x86 because that is what people are buying.
Motorola (now X-Scale), who used to make Apple's PPC chips, saw their future in the embedded market. Apple was about 2% of their sales. They had little or no incentive, and perhaps even a disincentive, to spend a lot of time and money making better desktop and laptop chips. It takes a lot of money to go toe-to-toe with the very smart people over at Intel, and for Motorola there was not much bang for those bucks. For every dollar in desktop PPC chips sold, they sold $50 PPC chips for everything from air conditioners to automobiles.
IBM uses the PPC in their Power series computers (which are both Unix and i5 OS). They view the Power PC as an embedded and server chip. Servers (especially large CPU count servers) are less interested in raw single CPU performance. They have plenty of other issues, such as backplane bandwidth, IO bandwidth, cooling, etc. to worry about. They're interested in the over-all performance of a multi-core, multi-cpu server. (I.e. 16 CPUs with 2 cores each). IBM had little incentive to produce castrated, low-heat versions of the Power architecture for laptops and desktops.
If Apple wanted to stay competative in terms of price and performance (especially in the laptop space), Intel is a probably their best choice. A major market for Intel *is* the desktop and laptop space. They are constantly striving to produce high performance/lower heat versions of their x86 or x86_64 chips that work specifically for desktops and laptops. AMD would have also been great, but for whatever reason they chose Intel. Either way - same basic architecture.
Power PC could be superior to x86/x86_64 in every single way, but if the companies that make the chip have no incentive to build competative, attractive desktop and laptop chips, then whatever theoretical benefits will never materialize. Moreover, for IBM and X-Scale the desktop/laptop market is a side-business and their focus is elsewhere. Both IBM and X-Scale see their long term Power PC plans in markets that are orthogonal to Apple's interests.
IMHO in the long run this will hurt both IBM and X-Scale. Constantly producing better and faster chips for the consumer market (always hungry for a few more clock cycles for FPS games), keeps your performance and speed up. In the 10 year horizon, I think X-Scale will evetually be marginalized to nothing, as very low power variants of common desktop CPUs will trickle in the embedded space. Why use an exotic chip, when you can prototype everything in VMware/parallels/Xen on your desktop? Eventually the $5 in quantity Power PC cpu will have so much less capability than the $5 Intel based CPU that Intel will take the embedded market. In the server market I think specialty processors like SPARC and PPC will get pushed into larger and more exotic iron. Eventually it will be more economical to build around the x86_64 platform than to maintain CPU R&D efforts for those chips.
Leave the gun, take the cannoli -- Clemenza, The Godfather
I agree completely, and will point out that there's a 10billion dollar a year business for mainframe systems to run bizzare ibm system/390 (31bit cisc) and burroughs 2200 (36bit cisc) green-screen applications. IT's not fast, or sexy, but there are tens of thousands of businesses who depend on these legacy systems.
The same, of course, is true in the PC world, where many corporations still depend DOS and 16bit windows applications. If I buy a machine with a whole new architecture, and have to replace all my software, the software and training costs are going to be several times the cost of the hardware.
It would require a huge performance and usability jump before anyone would undertake a change away from x86, and the x86 processors out there are good enough that any advantage a particular architecture might provide is very small. In fact, today's x86 processors are some of the best performing chips available. A better question might be why did we all use x86 processors in the mid-90's. At that time Alpha or Mips processors were often performing at five-ten times the rate of 486 or pentium processors. If the economics of switching didn't make sense back then, they sure don't make any sense now.
Binary, hex, and base 12 aren't "natural" since we have 10 fingers to count.
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.
...would be the DEC/HP Alpha. It's not longer in production,
and because of low marketshare it was ever a very high prized CPU.
So it's no option anymore.
My second choice would be MIPS. A very clean RISC architecture
without any compromises. But the development of it's hardware
stagnated years ago. You can buy MIPS CPUs, highly efficient and
powerful - for their clock rates. But chanceless against a multicore
mainstream CPUs with four or six times the clockrates the MIPS has.
No Option for a new Workstation processor.
PowerCPUs. Extremely high prices for the systems make them no option too.
The minstream varaiants which are available in actual systems are mainly
old G3 and G4 processors. Not the best choice for a new computer.
UltraSparc: The only RISC-processors which are produced in actual
production lines, build relatively (!) low priced Workstaions from
Sum Microsystems. They are payable by private user. So they would be
at the moment my Architecture of choice. But since i'm just a poor student,
even this price it to high for me. Which means i have to stay for the next two
years or so at the same ols x86-crap and the much crappier IBM-compatible PC
with al the ballast of a bad, 30 year old architecture. A Opteron or Core3Duo
would be my specific flavour. Maybe on one of the cheaper Tyan Workstation boards.
All other RISCs have gone to the embeddet market. StrongARM for example.
They're no choice for a workstation.
This is not only because of Intel money, as Cyrix, AMD, NextGen, Centaur, Rise, and others have proven, but simply because the x86 ISA has never been as bad as RISC vendors whish it to be. On top of that, FPU performance have increased tremendously (relative to RISC) in the later years - and that is probably the reasons you're seeing the traditional RISC machines on the retreat.
Cell is hardly as amazing as you make it out to be. A GPU can already accelerate task 'the cell' is good at, and do not need a radically different programming model. At the same time, there are numerous algorithms that 'the cell' never will be good at - although it might be good enough. In any case, there is little 'the cell' offers to a desktop environment (even with cell friendly coding) and don't forget that Mr. x86 has no intention of standing still.
Why do we still use x86? Because every gods-damn time somebody tries to change this, the market goes apeshit.
Hell, Intel themselves got tired of listening to the 'P4s are based on 20 year old design!' crap, and invented Itanium; next gen, breaks the mold, sings, dances, and so on. But oh noes, it didn't work perfectly on the very first iteration, and *gasp* wasn't so good at running x86 code, so down it went.
Vintage computer games and RPG books available. Email me if you're interested.
For all the academic arguments about what architecture is better (CISC versus RISC, pipelined versus superscalar, etc.) what's difficult to deny is that the Intel/AMD (and the x86 architecture in general) have continued to meet or exceed Moore's law. Despite Apple's insistence that PowerPC was a better and faster path forward, the facts are that Intel outran them. This doesn't necessarily mean it's a better architecture, but rather the engineering resources (perhaps due to AMD/Intel competition) managed to do more with what they had. Maybe x86 is performing at 95% of its potential, and PPC at 50%. Who knows. Who actually cares, except for an academic discussion.
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.
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.
https://www.accountkiller.com/removal-requested
Intel just knows how to make compilers work. Consistently across nearly all tests the ICC comes out on top. I remember an interesting test form one of the printed tech rags the office gets that had a large compiler test on a bunch of different things. They did Visual C++, GCC, Metroworks, ICC, and a couple others. Also they did version testing so you could see how they improved (like VC 6 and VC 7). Well it varied test to test how they ranked, VS 6 was nearly always at the bottom, GCC 4 was pretty good and faster than GCC 3, etc. However on EVERY test the ICC was the top. Every single one.
I think that's one of the possible reasons that x86 is such a good platform overall is that there's just this wicked good compiler for it. Your chip can be as good as you like in theory, but if there's not a compiler to support it, it is likely to suck in practise since hand optimized assembly is fairly rare (and often not as fast as people think it is, compiler often do a better job).
It's hard to move. And people like Intel for support engineering. Ok. Howabout we all agree to running 32bit code in emulation, and just cut huge chunk of old legacy processor support out of Intel CPUs? Smaller die. Lower cost. Faster clock (perhaps). 32 bit would be way slow, but once you've installed your OS, it'll scream for less $.
How awful would that be?
Shouldn't this have been filed from the 'I-don't-know-the-difference-between-possessives-a nd-contractions-and-now-everyone-knows-it' department?
-- Let him who is without spelling error ignite the first flame --
Actually, the writing is on the wall. There will be a new architecture in the 5-10 year time-frame. Microsoft has openned a design center in Silicon Valley, and I suspect that they are developing the IP for a MSIL core. They will then license this IP to any vendor (ala ARM). But how do you introduce a new architecture without an installed base of software (ala 29K, 88K, T800, Clipper, etc)? Well, any software that has targetted the CLR will run on the new cores natively, or with an efficient JIT translation (ala Jazelle). This should open the CPU market to many other players. A good thing. What about legacy code? For source code, there will be a tool for translating C to C#. C++ may be translated to Managed C++, or C#. Java also maps to C#. For binaries, there will be a load-time translator (HDD image is x86, memory image is MSIL), and perhaps an install-time translator (DVD-ROM image is x86, HDD image is MSIL). This is all just my speculation, but the text on that wall looks pretty clear to me.
The post mentions RISC is easier to make a compiler for. The x86 isn't strictly CISC and the difference between CISC and RISC had become less meaningful int he past decade since most instructions are translated into a RISC like micro code anyways. Power derivatives had some major advantages in design philosophy over the x86 but there wasn't enough advancement to keep up with the x86. Tons of money + a inferior starting design can still equal a faster end chip. a core2duo is still faster then a similiarly priced G5.
"There are more things in heaven and earth, Horatio, than are dreamt of in your philosophy."
Modern CPUs have sufficiently complex decoder units at the front of sufficiently deep pipelines that the programmer-visible ISA has very little impact on the performance-critical aspects of the architecture. You need look no further than the vast architectural difference between AMD and Intel, or even Intel and Intel (P4 vs. Core) for the proof.
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.
There's no failure quite as dissatisfying as a complete and total solution to the wrong problem.
I was an Apple developer for 10 years. I lived through the 68k to PPC601 transition. Apple pushed the throughput of RISK vs CISC; but it really wasn't about throughput. Apple had a deal with Motorola, and it was getting expensive to push the envelope on 68k. Intel on the other hand continued to push the envelope on x86; so much so that the real architectural difference wrt pipelining and such became irrelevant. Every RISC pushing the envelope performance test from 93 to 96 was a lie. Intel hit the market with x86 chips that were outperforming the latest (non production) PPC line. Doesn't matter that the architecture was counter intuitive. And if you ever looked at the 604 and later architectures; they were HARDLY RISC. So I say again, by 96, the RISC/CISC argument was dead.
... crap I forget that model ... but Apple killed that too by not publishing the specifications and crippling CFM. Course this fun stuff was tied to specific Quadra models.
As a developer, I found one of the most irritating things about RISC chips (PPC or Sparc) to be the binaries that were 3x the sizes... and for what? With Apple specifically, producing a FAT binary was a total PITA. The Code Fragment Manager was a total mess; but a nice hack to attempt to support runtime architecture switching. Now.... did you know that originally there was the option of running both 68k and PPC in upgrade machines like the 630 that had 68k running at the same time PPC was going on the expansion card? There was also the possibility of running code the DSP
Anyway I digress; one point I forgot to make was the huge performance hit when trying to determine what architecture to run on in the attempt to support multiple architectures (via brk!)
/\/\icro/\/\uncher
Risc prosessors are harder to program, they are expensive to manufacture and .. and .. and ...
Althought there are lots of good point in RISC instruction set it's got also problems. There ain't perfect prosessor you are looking into. Everything I have seen has at least two bad points againt three good ones.
-Seeing the problem is ½ of solution-
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.
I always wondered how the world would look like today if IBM instead of the intel 8088 had chosen the Motorola 68000 or 68008 as CPU for the PC.
;-)
I always thought that with the M68000/68008 the world today, at least for programmers, would be a better place.
What do you think?
You're right about the advantages of the CISC ISA vs. a RISC ISA, but I wanted to throw a few more points out.
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
That's the main question. While there once was a wider variety of CPUs in different computers back in the 1980's, the software developers graviatated toward x86 with Microsoft OS. As a result, most software that many people want to use is only available on Windoex/x86. Want to play HalfLife 2? How many choices are there? WOW is available for PPC Macs, but I would use it on my x86 PC instead because my Mac is an iBook G4 with Radeon 9000 mobile, and the user experience would suffer in comparison to the PC version on my AMD64 with GeForce 6600. While there is a version of TaxCut software for Mac, it's a cheaper version that is not suitable for my tax return, therefore I use the more advanced PC/x86 version.
It is curious that all current-gen game consoles have some form of PowerPC in them. But am I going to choose a console based on the CPU in it, or am I going to choose a console based on what games I like?
This question becomes less important with FOSS where many things don't depend on any particular OS or CPU, and can be ported to new platforms, but for the mass market this will remain a big theme so long as a lot of software is Windows-only.
And with the market the way it is today, still having such a dependency on Windows, it's nigh-insanity to produce harware with alternative CPUs. I'm a fan of AmigaOS, which is PowerPC based today. The one PowerPC desktop manufacturer that was licensed to support AmigaOS is now defunct. Apple left PowerPC. And the other PowerPC desktop maker just stopped shipping their "performance" motherboard with G3 and G4 options. Their current product is a low-performance 5200 CPU and the board is said to not fit any desktop case standard. AmigaOS of course finds itself between a big rock and a very hard place, as you cannot right now today buy any hardware that it runs on for general computing uses. There's companies working to bring new hardware soon, but they will surely find the market challenging to survive in. I'm happy someone seems willing to try. A number of users want AmigaOS to convert to x86 in order to ease the burden of keeping hardware available for it and for no other reason, the performance or features ofthe CPUs are irrelevant to many.
I very serously looked into a PowerPC laptop project, but the hurdles are humungous and come in large numbers. It would take a large, established, and wealthy company to actually do such a thing, and all of them seem to prefer x86 for desktop/laptop general-use computers. How do people "choose" anything in such an environment?
I pledge to use the x86 architecture until Cliff learns the difference between "their" and "they're"
Here in Venezuela is hard to find (if is not impossible) another architecture, besides of the high popularization of x86 and a lot of software already avaible for this architecture.
I knew about the nightmare of older Mac's PowerPC-based, Flash, and with the change to Intel Apple was looking for more users, by the popularization that this architecture already have.
ghostbar page.
Isn't it because all of the alleged advantages of other architectures just weren't compelling enough? And because unless you've got a rare sense of aesthetics for processor architecture design, nobody really cares what kind of chip is in the machine?
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.
In the beginning, Microsoft got lucky (with IBM) and PCs became prevalent. Microsoft made/ported DOS to run only on x86 machines. This drove the processor manufacturers to focus on producing chips for this platform. Even though the x86 architecture is inefficient, it became the largest market so they invested making faster x86 processors. Fast forward to today, we have super fast, inefficient processors that exist solely because Microsoft never decided to use a better architecture. If Microsoft had better programming practices, Windows would be cross platform but of course their software sucks, so this is not the case.
As history shows, the better technologies do not win most of the time... the most widespread ones do.
Recently I saw a stat that about 40% of the power consumption in California goes to feed server farms. Given that, even a 1% savings is millions, possibly billions of dollars worth.
~REZ~ #43301. Who'd fake being me anyway?
Economics. The most popular CPU architecture gets all $$ for expensive fabs and R&D. The cost of development & production's amortized quite a bit when you sell a whole lot of them. Intel's only competitor for speed is AMD, both essentially the same architecture. The top dogs get exponentially more money for that stuff than the kids after them, and it shows. No matter how much I'd like it the other way (I'm a mac/ppc fan myself, and loathe giving up codewarrior).
As for multi-CPU OS's, or whatever I've been reading on the comments here, why? That's a lot of debugging for all those CPU architectures (think of all the compiler backend bugs you can hit, endianness issues, binary & ABI management issues, etc), for what? The user doesn't see much of a difference between them, and "cleaner architecture" means jack squat to them.
Us computer scientists can wish for cleaner architectures (and just 4 more registers, please!) all we want, but that doesn't change the market. Besides, we shouldn't worry about it -- it's 2007, we've got much bigger fish to fry.
Care about electronic freedom? Consider donating to the EFF!
I think we could assign value = 4 to thumbs (since they are the oposing finger to the others) and then we would be using hexadecimal which is my favorite.
Ave Maria
What it comes down to is not that the x86 is better, but rather Intel gave their customers what they wanted.
Win NT ran on DEC, PPC, Alpha, etc, etc but no one bought the machines. Everyone wanted the cheaper x86 based systems. Apple had a very good run with the PowerPC, but in the end the manufacturers (Motorolla and IBM) dragged their feet on upgrading to faster technology, weren't able to produce them at a low enough price point, etc. Apple was forced to switch so they could continue to compete.
So while the PowerPC was architectually supperior to the x86 it was seen to have a lower ROI in the consumer, SOHO, and finally business markets.
We already can count on binary on our hands. You can count to 1023 by using each of your fingers as a bit.
OK, everybody, let's switch to Windows. "Because sometimes it's easier to stick with a standard". But nevertheless the easy way should not be always chosen.
When 98% of all processors are 98% idle 98% of the time, does it matter?
The vast majority of lusers dont need a computer.
They buy them because they think they are supposed to so they don't get left behind.
Do people in general do more with a faster computer? I dont think so.
Computers are only as good as what they're programmed to do. People are forced to buy new home computers to use software that is bloated and for the most part does the same thing that they did in the 386 days.
What people do is read email, browse the web, and maybe write a resume.
The pseudo bohemian with the square glasses and the latest shiny white apple notebook at starbucks.. is doing what with it? Posing?
Home computers for most people are very similar to toasters. They sit around doing nothing most of the day. As long as they can read their email, and browse their porn, they're happy.
We geeks often lose sight that we are not like everyone else.
What we want, need, and do is not what the majority wants, needs, or does.
...because a company in Redmond didn't want to support any other architecture... partly because their code was a pain in the ass to move.
x86 has really been RISC under the hood since the original Pentium. They had too to keep up with Moore's law. The fact of the mater is that x86 is a standard for PCs just as much TCP/IP is a standard for the Internet. Is TCP/IP the best possible protocol ever invented for the Internet? No! Is x86 the best ever CPU architecture? No again! But, we use them because they are standards and most importantly they work. The industry has long ago decided that x86 is the standard and it is easier to add compatibility layers than to use new architectures that are non-standard. Just like we are squeezing performance out of TCP/IP we will still be squeezing out performance of x86 for years to come.
we use windows. that's it.
I'd say the main factor is that nearly all the software was x86. NT could run on other hardware, but it was still running x86 software. And if you were running x86 software anyway, you might as well run it on an x86, especially since they were much cheaper than the non-x86 boxen.
Slow down, cowboy! It has been 4 hours since you last posted. You must wait another few hours.
As I understand it, it costs about $100 million to set up to make a new chip, then about $1 a chip to manufacture. So if make 100 million CPUs, your total cost is drastically less than if you only make 1 million chips.
But if you have friends over, how do you let them all play at once? Are there first-person shooters that can take four keyboards and four mice plugged into a couple USB hubs? Does Windows even allow that? And what about people who prefer genres other than first-person shooters or ESRB ratings other than M (or foreign counterparts)?
The One Laptop Per Child project is a start, at least to get people thinking outside of the beige box of uniformity we have now. Here in the west, it will be appliance like computers, like specialized browser boxes, black berries, iPods, cell phones and rest..
How can a platform used in three video game consoles, including one without a lockout chip (allowing it to be used as a personal computer), be dead?
http://www.pegasosppc.com/odw.php
It was a powerpc machine designed to run Linux, OpenSolaris, BSD and assorted OS's like that. Due to the discontinuation of the product that you mentioned, your comment had tense errors, which I fixed and emphasized above. Is a similar product still manufactured? Or is PLAYSTATION 3 the most viable PowerPC based workstation today?
x86 only refers to a set of API interfaces with the CPU architecture. As of the launch of the Pentium, the modern "x86" processor is a RISC based CPU with an internal x86 translation layer. Start you learning here. x86 is also refered to as x86-32 or IA-32. And with the current generation of processors, we are leaving that behind for "x64" also known as EM64T, IA-32e or IA-64 in its various iterations. Many of the "x64" series generally maintian "x86" interface compatibility in order to allow legacy operation. For instance you can run Warp Server on a dual Opteron server just fine.
The performance-per-dollar has always been pretty outstanding. On top of that, there's the positive-feedback effect of nearly all software being available for it.
There are a lot of nifty features in "bigger" or "better" architectures, but if you don't need those features, it's hard to resist spending just $500 and having a spankingly fast machine.
64-bit ARM? I'm not big on the ARM architecture, but it's always seemed like a low-power (electrically), low-cost solution, it hasn't seemed powerful enough for most people's general needs.
If anything, it's always amazed me how often x86 chips get used in embedded systems, both for the low cost, good performance, and the fact that x86 coders are probably more plentiful and cheaper than ARM coders. Many years ago, it surprised me to open up $30,000 portmaster 3's, and see that they were based on an AMD 486-knockoff. (If I recall correctly).
Oh, you're not stuck, you're just unable to let go of the onion rings.
If you ever get a MacBook, you will literally be able to drag and drop most software from your PowerBook and expect it to run.
The PPC to x86 transition is the second one Apple has made, and the reason it works is that each time, they switched to such ludicrously faster processors that emulation (JIT compilation) still made programs run faster on the new systems. From what I hear, PPC programs run twice as fast on a MacBook Pro as a Powerbook, and Universal binaries run four times as fast.
So, that is how x86 would get replaced. Actually, Transmeta tried that -- they created their own architecture, and emulated x86 in firmware. Unfortunately, their chips are obscenely slow, and they haven't given us any compilers for their own arch, so it didn't work well -- but that's how you'd do it. Make your chip fast enough and your JIT good enough that it's actually not a performance loss to run x86 on <insert new architecture>, and people will switch. Which is sort of what's happening with x86_64.
But don't make Transmeta's mistake -- actually give us a compiler for it.
Don't thank God, thank a doctor!
because the OS that 95% used was only for x86. yes I know NT was available for other platforms but most people didn't use NT. Windows 3.1, 95 and XP are what mattered. If all versions of Windows were available for other platforms, they would've competed with intel and would be much better alternatives than they are today
Firefox Power http://firefoxpower.blogspot.com/
x86 CPUs are by far the cheapest per performance CPU that will run all the old software. For awhile it looked like Transmeta was pioneering a transitional architecture with enough raw power in its backwards-incompatible native operation to waste emulating legacy CPUs like x86 or PPC. But Intel adopted successful Transmeta tech strategies to make new x86es faster than new Transmetas. Meanwhile, PC/server/workstation makers didn't take the risk investing in the transitional tech.
However, the x86 arch is already running into limits new strategies can't jump without real transformation. Transmeta's approach might prove to have been merely premature. Meanwhile, software is increasingly designed for parallelism to scale. Which incidentally can open system architectures to new CPU architectures, especially for special purpose processing.
Telephony and other integrated networked multimedia apps offer lots of chances for new architectures. Lots of new SW is needed that can use whichever HW offers the best solution. DSP, mobility, scalability and other niche requirements mean that
And with projects like uCLinux and even the lingering NetBSD, we have a fairly consistent platform for continuing to use existing tools and techniques to move more people into connection with each other.
--
make install -not war
As we approach the maximum supported amount of RAM for 32 bit CPUs, the computing world will be forced to transition to 64 bit. When this happens, there could be a chance for another architecture to take off, but in all likelihood AMD64/x86_64 will be the winner and not PPC64, IA64, or anything else.
There is more to science than physics!
www.iomalfunction.blogspot.com
This was a really relevant discussion, about a decade ago! Set your wayback machine and take a look at the cpu architecture discussion going on at the time and follow their ultimate path. Your answers are already written.
For the program I work on, there was a deliberate move from PowerPC to x86, and the bottom line justification was performance per watt and the related significant advantages in cooling. There were some potential cost savings, but the cost of the chip was not a primary discriminator. For embedded computing applications, size, weight and power (SWaP) concerns dominate. The secondary consideration was software availability. There are some items that are just not available for PowerPC, and we were unsuccessful in getting a vendor to consider a port of their X86 Linux product to PPC Linux. (This program is an 800 lb gorilla, but the vendor wouldn't budge. I guess it's "gorilla vs elephant" and the elephant won.)
Apple has given performance/watt as one of their justifications, too. (Ability to run Windoze is clearly another big advantage, and I'm looking forward to a new MacBook Pro where I can suffer the occasional Windoze-only application while having my Mac cake too.)
Now I know IBM claims to have engineering breakthroughs in PPC performance & cooling, and we certainly saw substantial benefits to the PPC architecture particularly for floating point performance. But for about 2/3 of our apps, integer performance (where x86 does better) predominates, and one thing we really do NOT want to do for logistical reasons is to support multiple CPUs. That's both a development and a field support/supply nightmare.
dave
12 is perfectly natural - if you're counting on the knuckles of your fingers, using your thumb to keep track. Then, if you don't have the dexterity to do that on both hands, you use five fingers to keep track of how many twelves - and then you're at 60. That old system does make sense, for a people with a different habitual method of counting on hands.
Just a personal observation, but I have a notebook powered by a 1.3 centrino set, cooled by lamier heatsink and fan.
And I have a 1.4 Mac Mini cooled by a crappy little alluminium heatsink and a dinky little 30-40 mm fan that also cools the radeon chip.
The notebook has a new hard drive with a better heat profile than the 7200 rpm drive that I have put in the mini.
The notebook has a larger surface area to disipate heat and more ventilation.
Accepting differences in the graphics chip, os etc.. I perceive the user experience to be roughly the same.
But, and here is the thing, I leave the mini running 24/7, the fan is only ever audible on a very hot summer day and the case is usually fairly cool. On the notebook, I have cpu throttling/fan control software and even then if it is doing anything other than idling, the fan will spin up fast enough to be a distraction and the unit is nearly always hot. It's not an isolated thing either. I am always fighting a losing battle to get an intel based unit cool and quiet. Maybe the newest chip families are better, but I gave up a year or so back.
For my 2 cents, the power pc is a better platform for the average computer use. Gamers will always be an exception, but with consoles slowly outstripping PCs for gamers, that may change.
And say, didn't the xbox swap from x86 to power when it went to the 360?
Intel can afford to throw heaps of cash into developing x86 chips as there's a huge, guaranteed market for it. Intel were able to ramp up performance on x86 faster than IBM could on POWER, hence Apple's switch. Apple topped out at 2.5GHz G5 PPC chips 18 months after IBM had promised they'd be sitting on 3GHz.
There's also the mobile market - Apple, and I'm sure other manufacturers, now sell more portable computers than desktops - Try as they might, Apple simply couldn't cram a G5 core (or two) into a laptop and not have it fry your gonads, and get any kind of performance and battery life out of it.
Sure, the x86 arch is a kludge on top of a hack on top of a microcontroller ISA that was never intended to be a general putpose CPU, but the fact is it works.
The ISA is ugly, but internally the chip is pretty well RISC anyway and all the vector instructions (MMX, SSE etc) have definitely helped over the years.
There's a huge base of knowledge centred around x86 - from ASM level programming and compilers, through to apps, libraries and operating systems. Now that Apple are on board with the mass market, being able to run Win32 apps on a Mac is great.
Specialist Mac support for creative pros, Melbourne
>> How long do you see Intel maintaining its dominance in the home PC market?
As long as commercial PC games Developers don't provide source code or binaries for any other architecture.
1. Development of efficient compilers and high-end IDEs. Without having to see the mess that is x86 machine code, you can usually ignore it. People made a clamour for clean RISC machine code in the 80s, but within a decade very few people really cared anymore.
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?
Man is the animal that laughs.
And occasionally whores for Karma.
The answer is the same as why we use IDE (and now SATA) over SCSI, USB2 over FireWire800, Ethernet over token ring. It's good enough and it's cheaper. There are many technical advantages of each technology over the commonly used ones, but practicality always rules.
Well, there's spam egg sausage and spam, that's not got much spam in it.
I thought ARM CPUs were the most used in the word and that Texus Instruments were also in the top five, possibly before AMD. Intel/AMD CPUs are mostly only used in desktops/servers. Once you step beyond a standard "PC", many different CPUs are used. You've effectively asked "Why do people who use Intel CPUs use Intel CPUs?" -- in which case the answer is "because they do", rather than anything helpful.
I could care less about "better performance per clock". I care about "performance". The Apple switch as proven that the x86 CPU's are faster. End of conversation.
I'm not sure if this is even possible and I'm sure it would be a huge thing to do, but it would also make Microsoft look like heroes. Would it be possible for MS to start a standards organization for hardware that can efficiently execute their proprietary code and start to build a Windows based on that along side with the x86 architecture with plans to switch down the road. Honestly I don't really know, fully, what I'm talking about, but that is why this is more of a question than a statement. Any suggestions?
M$ supports it (and possibly owns shares in x86 technology manufacturers).
because RISC vs CISC and microkernel vs monolithic ones were always false dichotomies, or at least ones mired in a specific time that no longer exists. Internally, modern CPUs and operating systems are a blend of different technologies due to advances in the state of the art knowledge and changes in the underlying technologies and constraints. x86 CPUs have been RISC internally for a long time now. RISC no longer means 'reduced instruction set' but usually implies a 'load-store' architecture rather than one with less instructions. for a long time, silicon was precious, saving the cost of a complex instruction decoder was worth it. nowadays, chip designers (in the desktop cpu market, embedded systems have different concerns) can't figure out what to do with all the space on the die they have available. decoding complex instructions into simple RISC ones is just a non-issue. Arguing about them nowadays is like still arguing about whether we should adopt beta vs VHS. The technologies still have meaning to compare and contrast academically. but the need for the argument itself has been obsoleted.
http://notanumber.net/
Most comments focus on the past and ignore the future. :-)
:-)
x86 drags along a heritage of compatibility: that one way or another takes its toll.
Well I guess that's about to change. x86-64 could soon be upon us. What's this? It's the old processor running **exclusively** in 64 bit mode, no longer dragging along old habits.
Why is this to happen? Answer: multi-core processors only need one core to be fully x86 compatible. All other cores can be modern cores and x86-64 only.
Now that's going to be a winner! I should be paid for this, so copyright reserved
x86 always was a winner, purism aside. Other 'better' architectures mostly didn't really deliver. Now we can have the best of both worlds: please stop buying symmetric multi-core
X86 performance is decent, and performance per $ and per watt is excellent. RISC code can use more memory (and thus, consume more cache) due to the increased number of instructions to do simple tasks, as opposed to a single more complex instruction.
Unfortunately, unless you're starting from scratch and throwing away backwards compatibility (which will never happen unless there's *real* compelling reasons to do so), it's a no-brainer.
Sure, you might *feel* better not running such an inherently brain-damaged architecture, but in reality the reasons just aren't there.
Actually that's probably a little unfair. I suspect that intel really wasn't counting on the success of the 8080 (and thus, 8086 -> x86) - given that the market has wanted backwards compatibility, they've done an amazing job all things considered.
I run: Windows, OS X, Linux, FreeBSD. Just because you have a hammer, doesn't mean everything is a nail.
If Inte themselves couldnt do it when they tried to make everyone switch to ia64 with the itaniums, who could?
Carpe Diem: Seize The Day!
It also helps a lot to realize that many conversions require very little accuracy. For example I often consider a km to be about half the size of a mile. That's good enough to get a feel for many distances.
I think that JIT (which I call dynamic) compilation is a good idea because it would allow binary executables to run on different architectures. I have posted to comp.arch a programming language which would produce the same result on different architectures while retaining the flexibility of C here.
So they're going to try and tell us that the fact that sticking to a proprietary hardware platform kept them almost entirely irrelevant throughout the company's history had nothing to do with it? ;-)
To paraphrase a saying...If you believe that, I recently acquired this really beautiful bridge up in Sydney which you may be interested in purchasing.
stuart
Not quite, I have an Alpha running NT4, which it came with. Of course because I couldn't get much software installed it was basically a waste getting it.
FalconShould there be a Law?
IIRC, Dec Alpha, The Sparc, PPC, and x86 were all supported by WinNT. No one bought WinNT for anything other than x86, however.
I realize I'm a nobody yet I bought an Alpha running NT4.
FalconShould there be a Law?
It is so we can be compatible with the 8080 registers
set, to allow the running of CP/M. Don't you remember?
Ohhh, That was the 8086 from from more than a couple of
decades ago.
Development tool cost.
Yes, the x86 still have better code optimizing compiler for cheaper and less bugs than the other vendors period.
As much fun as religious flame wars were back during this debate; it is a total was of space and time. Especially now when desktops are stuck on 1 chip design.
As far as we know now, the increased integration 10 years from now may end up splitting up design; where fab plants make chips which contain multiple products possibly from different vendors on the same die. We could have smarter designed chips with microcode translators...wait x86 has that already. Well, we could have an AMD cpu, ATI GPU, intel 100gig ethernet, intel memory controller, and an IBM programmable gate array... who knows.
I for one would gladly welcome more system on the chip over more cores I won't use most the time.
Democracy Now! - uncensored, anti-establishment news
per dollar of advertising, I think you meant to say?
a different name for legacy software, but gives a better mental image of the problem...
hell, not even microsoft can fully shake of the effect of software intertia. thats why they keep stuffing in backward compatibility patches that come back to haunt them as security flaws later on.
i may be preaching to the already faithful, but the only short term fix for this is FOSS...
this because it allows the "user" to recompile the software for a new platform.
ok so we are hitting the spot where the modern computer have so much computing power that it can pretend to be a computer thats a few generations older.
but still, thats a patch job taken to the nth degree...
thats like a human being having a micro climate inside them to keep a beneficial bacteria alive generation after generation.
the other option is to go FPGA, or whatever its called, that can mutate in real time into legacy chips. but i guess that would be emulation on hardware rather then software (and are there not corps that have tried just that?).
comment first, facts later. http://chem.tufts.edu/AnswersInScience/RelativityofWrong.htm
"I didn't mean the Altair was Greater than Eniac, or better than Eniac, just, at the time, it was more popular than Eniac."
If you design your RISC CPU's instruction set around popular language environments such as Java bytecode, .NET bytecode, and the operations available in C++, then you've covered most of the bases. ARM got this very right.
They did, and it was called GS/OS for Apple IIGS.
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.
Okay, let's substitute x86 with VHS, and let's substitute x86 improvements with VHS improvements:
3. Every fundamental architectural improvement in VCR design has been integrated into the VHS family. Academics and designers alike said it was impossible, but VHS today enjoys all the benefits of real time displays, automatic head cleaning, index searching, high fidelity audio, higher chrominance bandwidth, higher luminance bandwidth, Beta skip-scan, and a tape threading mechanism which is almost as reliable as the trusted Betamax U-Load...you name it, it has been implemented on a VHS VCR. (Yes, it is that stupid, and yes it is that after-the-fact. Intel, like JVC (VHS), waited for someone else to develop it, then figured out a mediocre way of tacking it on to their existing product line.)
Problem is: as with VHS vs. Beta, these are inelegant hacks applied after the fact to retain market share, rather than designed in (as standard features if not options), with the resulting kludge factor. But my hat is off to Intel: with the extra architectural complexity they've added, it's damned near amazing to me every time my computer actually POSTs. (Note that I run AMD, I may be forced to use the x86 mess for a variety of reasons, but I will damned well never patronize the merry band of fucking smegma-dicked morons who invented it. I wipe my ass with litte endians.)
Fire and Meat. Yummy.
What is Windows XB other than a target for game ports?
In fact, this is not so much of a problem. Compability with the Intel 386 is roughly what is meant with x86-compatible. The transistor count for 386 is 275000 (Wikipedia). The new Core 2 Duo contains 291 million transistors. That means that with less than 0.1% of the processor transistor it can fully implement a 386, and run it much faster than in the old days since it would be built with much smaller/faster technology.
Of course this is a simplification, but considering that x86 can be implemented in 275000 transistors, it shouldnt require so many transistor in a modern cpu to translate x86 instructions into internal RISC instructions (which is exactly what Intel did since long).
Thus, the extra cost/penalty for implementing a more than 20 years old instruction set in a modern CPU is virtually zero.
When it comes to compilers... I almost always found to my disappointment that my C programs compiled with GCC run faster on Intel than on PowerPC (for the same clock frequency). I guess much more work has simply been put into x86 compilers.
U coward, you don't even have an intel mac. I'm posting on the macbook pro, where I hardly notice the difference even when I open up Photoshop 7. You have to push certain software hard to have it become a speed issue. (windows xp on here sometimes feels more 'emulated'.)
Back when I bought photoshop 7, it ran on the best mac at the time and then I used it professionally-- my macbook pro emulates it about that speed from my experience. Its NOT horrid performance, and only a few special cases is it bad enough for concern (Vector Works is like back to 1998.)
Its not like previous speeds are the end of the world, people DID make livings on computers back then. You know, even in 1980s (when you were born?) computers helped productivity so much they became wide spread.
Oh, now there is better emulation, >1 cpus, more idle cpu time, more ram/disk for caching, and the biggest language is JAVA which is NOT cpu specific!!
Even scripting languages are in many video game engines now.
Its not just the ISA getting less important due to abstraction.
Democracy Now! - uncensored, anti-establishment news
An ever-time Mac user, when I heard of IBM's (PPC compatible?) Core work (before the Job's decision to run with Intel, at least for a while), and that they were working towards an 8 core initial release, where each core could independently or in unison capable of running an operating system independently and simultaneously , I was quite literally ecstatic (that is at least one of the less disparaging comments my mate made as I walked around hugging myself in gleeful anticipation of Mac & Penguin & 'dozer all just >thereI & when I needed any of them!) Ans so Jobs decided on Intel. And I stopped hugging myself. Maybe next decade? Jen of Bisbane
Intel got into the lead and as a result had the most money to spend on research and development, not to mention being able to build ever more capable chip foundries. The R&D budgets for competitive architectures were measured in millions while the R&D budgets for x86 was (and is) measured in billions. Better yet, the billions are being spent by more than one company which guarantees multiple points of view being applied to each new problem. The effect of budgets like that ripples out and has many effects the give the x86 an advantage. There is now an entire culture around the x86.
Having now reached the 64 bit stage there is little chance that the x86 will go away any time soon.
Stonewolf
The availability of software is certainly a factor; as long as Windows is popular x86 will have market share, and while Linux is functional on a wider range of hardware, it is still best supported on x86/x86_64.
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.
But don't forget - the XBox 360 runs an OS derived from Win2K, and Windows CE runs on ARM, MIPS, and SH. As Microsoft gets into the devices market, they're going to have to support more and more types of hardware.
Downmodding is the refuge of the weak. Don't downmod, make a better argument!
Yet, they have not recognized yet that they are no longer in that position.
There is plenty of innovation going on, most of which is bought by the so-called market leaders
the sooner that they realize that it would eat into their profits and by that would cost them a lot
of market share.
Remember when Intel licensed stuff from AMD that essentially made things easier with 64bit computing and all?
Intel tries to remain in the position that they have not excelled in by the day that they realized their very
first processor "architecture", something I would term as being the least of the least things that I would think
of implementing in anything that I would someday then or future-wise would have devised.
However, they have strong marketing, and that is what sells, nowadays and then way after.
I remember the time when I, in my first essential project, had to build up a computer from scratch, based on some
x86 cpu, eventually soldering all connections required by my self. Later then I had to program that god dam thing
as well, not exactly the self-soldered single board computer, however, I learned that the Intel architecture is all
about keeping the past alive and well and by that also the company alive and well, by no means ever going into different
directions, that might have been more benefiting to the overall customership (see the original writer).
Instead, they bought out the xscale architecture from arm, which, actually, by far expelled the Intel based architecture
by far, however, I do not see any desktop products produced today that use the very same architecture, instead, we
strive with the very same old architecture that we had back then in the 1970s...
Somehow, this reminds me of M.
Regards
Carsten
it is not _expelled_ (note to my self: remember) but excelled
*g
And, additionally, it is M paragraph sign and not just M. Why does slashdot still not support the new synonym given to M$?
I mean, they are more into legal issues than ever before, with all their trivial patenting (off topic now) stuff going on,
the same with Intel...
Most comments focus on the past and ignore the future.
:-)
:-)
x86 drags along a heritage of compatibility: that one way or another takes its toll.
Well I guess that's about to change. x86-64 could soon be upon us. What's this? It's the old processor running **exclusively** in 64 bit mode, no longer dragging along old habits.
Why is this to happen? Answer: multi-core processors only need one core to be fully x86 compatible. All other cores can be modern cores and x86-64 only *)
Now that's going to be a winner! I should be paid for this, so copyright reserved
x86 always was a winner, purism aside. Other 'better' architectures mostly didn't really deliver. Now we can have the best of both worlds: please stop buying symmetric multi-core
*) In fact all cores can be x86-64 only because legacy modes can be emulated in software.