r******y
发帖数: 3838 | 1 大牛或专业人士评评这个。
我个人认为随着CPU速度已经满足普通需要，RISC这种容易为特殊任务优化的架构比
CISC更有优势。
http://www.tgdaily.com/hardware-features/65123-on-arm-versus-x8
Posted August 2, 2012 - 05:52 by Guy Wright
It seems like everyone in the industry wants to compare ARM (and other
variants of RISC processors) to x86 (and other variants of CISC processors).
For example, analysts ask, can Intel muscle it’s way into the mobile
market? Can ARM sneak in the back door of the tablet, laptop, or even
desktop markets? Who is faster, more powerful, cheaper, uses less power,
less space, and generates less heat?
These are not easy questions to answer and the major players spread
misinformation by the shovel full. So let’s take a step back and look at
what makes each technology tick.
RISC (reduced instruction set computing) technology has been around since
before the acronym was even invented.
It goes back as early as the 1960s (it could be argued that the CDC 6600,
one of the first supercomputers designed by Seymour Cray in 1964, was a RISC
machine).
The term ‘reduced instruction set’ is a bit misleading since modern RISC
processors can have just as many instructions as CISC (complex instruction
set computing) processors. The primary difference is that in a RISC
processor all instructions are formatted exactly the same way and all take
exactly the same time to execute – usually one cycle per instruction.
To achieve this consistent, compact design many instructions and addressing
modes that were built into CISC processors – such as floating point
operations and division – were not included in RISC processors. These
operations were usually offloaded to coprocessors.
This approach meant that instructions could be executed very, very quickly
and the chip architecture could be simplified. RISC processors tend to have
far fewer transistors than CISC processors - as few as half the number in
many cases. And fewer transistors means less power, less heat, and a smaller
footprint, features that make them ideal for small devices with limited
power.
Also, because the architecture is simplified and performance is so
predictable compilers can be optimized to eke out every possible iota of
performance. Of course, RISC processors have grown progressively more
complex over the years and as each licensee adds their own twists to the
original architecture the stack of developer manuals gets taller and taller.
The main reason that game consoles (which use RISC processors) perform so
well is that there are no surprises. Developers know exactly what the
hardware is capable of and can optimize their games to use every ounce of
power. They don’t have to worry about different screen resolutions or
vagaries in graphics cards or unpredictable performance hits if the user has
multiple applications running – the environment is always the same.
You could also argue that the performance of all-things Apple is also a
result of carefully controlled, very predictable hardware and software
environments – develop for a Mac or an iPad or an iPhone and you know
exactly what you are getting into.
To use an Olympic games metaphor, the RISC architecture is like an Olympic
pool. It’s exactly fifty meters long. Not forty-five meters or fifty-two-
and-a-half meters or whatever the pool just happens to be. It’s very
specific, and since it’s so specific swimmers can hone their technique to
fit the pool.
They know, with a good amount of certainty, exactly how many strokes it will
take them to get to the other side, turn, and head back. Toss those same
swimmers in the ocean and tell them to race out to that piece of driftwood
and back and you might have different winners standing on the podium.
Yes, there are some downsides to RISC processors. For one, as I mentioned
earlier, certain tasks (like floating point operations or division) can’t
be performed with a single instruction except in some of the newer RISC
designs.
So even if a single instruction runs faster on a RISC processor than the
same instruction on a CISC processor, it may take dozens of instructions to
perform some operations that a CISC processor can do with a single
instruction.
And there is a double-edged-sword with RISC technology. The companies that
develop the designs don’t actually manufacture the chips – they license
the technology (referred to as cores – reusable, and sometimes customizable
, blocks of logic or chip layout designs) to other corporations.
And like any good department store would do, they lower the licensing fees
on older versions of the design.
So if a manufacturer wants to
use the latest and greatest version of a RISC design, they pay a premium,
but if they don’t need the latest and greatest features for a particular
application they can license an older version. Nearly every RISC
architecture design ever developed is still available if you want it.
Now for some manufacturers this is a good thing. If you need a chip to run a
waffle maker you probably don’t need the newest RISC cores – you can
probably get away with an older design. But it also means if you’re
developing a chip for a new smart phone and just want to save a few bucks
you can license a design that’s a few revs older than the newest design. (
Granted, you can also buy older versions of CISC chips too, but companies
like Intel don’t manufacture 286 or 386 chips anymore).
Also, companies that license cores can modify them to suit their specific
needs, so, for example while the Nvidia Tegra Kai processor slated to power
the Microsoft Surface tablet may be based on the ARM Cortex, Nvidia has
already stated that the Tegra line comes in a variety of configurations with
and without certain features.
The CISC architecture, as the name implies, has a richer and more
complicated set of instructions built into the main processor. This
complexity sometimes comes at the expense of performance but it can
also provide more muscle when performing certain tasks. It also makes it
easier to program complicated tasks (although achieving high levels of
optimization can be more problematic).
The CISC architecture approach began in the days when RAM was expensive (and
comparatively slow by today’s standards) and programming was done at very
low levels (programs were written in assembly code rather than higher-level
interpreted or compiled languages). The more functionality built into the
main processor the easier it was to program and, in most cases, it was
faster than moving data back and forth from memory (or even worse hard disk-
based ‘virtual memory’). A divide command might take a handful of clock
cycles to complete but it was damned easier than building a divide sequence
of instructions when all you had was add, subtract, multiply, and compare.
One disadvantage of the CISC approach was that designers had to account for
a lot of different possibilities, and that meant sometimes there was
functionality built-in that wasn’t actually used. It might take the same
number of clock cycles to perform a simple operation as it did to perform a
complex operation. It also meant that it was harder to predict performance
because different instructions would take a different amount of time to
complete.
Another disadvantage is that all this functionality comes with a cost – the
more functionality you build into the processor the more transistors you
need and more transistors require more power and that means more heat,
higher costs, and sometimes a larger size chip. (You can get around the size
problem by making the circuitry smaller but that raises the cost. You can
reduce the number of transistors but that means less functionality. You can
get around the power problem by running the chip at a slower speed but that
makes it, well, slower).
Of course, there are two non-hardware specific advantages to CISC. First,
Intel is a mega-giant in the chip design and manufacturing business with
lots of money and some very big guns so they can devote enormous resources
to customizing the x86 line – resources than most RISC developers can only
dream about. Second, there are roughly a zillion applications tailored to
run on x86 processors.
Now that second advantage doesn’t hold true in the mobile space where there
are roughly a zillion apps tailored to run on Android and iOS. Granted, a
high percentage of those mobile apps could be considered trivial (not a lot
of acoustics modeling, 3D rendering, or CAD apps written for smart phones...
yet).
So which processors are better? Depends on what you are trying to do. If you
’re building a mobile device and don’t care about some of the more
advanced features (or can live with stripped down versions of them) then
RISC is a good choice. If, on the other hand, you want to do some serious
hard-core processor-intensive tasks then CISC processors are the way to go.
Try as they might (and they’ve been trying for years) Intel just can’t
quite get the hang of developing embedded processors. And while they have
tried (and failed) on various occasions, RISC processors just can’t seem to
crack the desktop market. Maybe that will change in the coming years as the
lines continue to blur but it probably won’t happen overnight.
And a quick historical footnote: Ironically, Intel first developed the 8080
– forerunner of the x86 line – back in 1974 as a low-power, reduced
function processor for calculators. ARM processors, on the other hand, began
life in 1985 when Acorn Computers released a new chip based on the MOS
Technology
6502 processor and called it, logically enough, the ARM-1 (Acorn RISC
Machine).
Read more at http://www.tgdaily.com/hardware-features/65123-on-arm-versus-x86-part-ii#Lr7jXcAic4QeAfLy.99
Read more at http://www.tgdaily.com/hardware-features/65119-on-arm-versus-x86#RJi1MqDVU9Sil1xO.99 | p*********r
发帖数: 4593 | 2 I didn't go through the entire article. It's just too long. I guess I pretty
much know what's going on. I witnessed Intel using its manufacturing and
large volume advantage to kill RISC one after another(I am old enough).
However, this time. it's different.
* ARM has much bigger ecosystem in the mobile space than all RISC processors
used in the workstation/servers before. Now its ecosystem is even bigger
than x86 in PC in terms of volume if you count all mobile phones, tablets,
and even some of the media players.
* Many companies making ARM chips can survive with low margin. That's very
different than all the companies were making RISC processors before, such as
IBM, Sun, DEC and HP, and MIPS.
Can Intel this time kill all ARM with its advantage on the manufacturing ? I
don't think so. Yes, Intel has 1-2 years ahead in terms of manufacturing
process, but cost of manufacturing is not low.
Here are the key factors that Intel killed all RISC processors before.
* 1.5x or more in the performance.
* Same power consumption
* Same price range or lower.
In order to kill ARM. x86 processors still have to do the same.
This time I seriously doubt because Intel can achieve the last one(price).
Intel has been selling ultra low power mobile CPU for at
least $150. Can Intel sell it for $30-$50 ?
).
mobile
【在 r******y 的大作中提到】
: 大牛或专业人士评评这个。
: 我个人认为随着CPU速度已经满足普通需要，RISC这种容易为特殊任务优化的架构比
: CISC更有优势。
: http://www.tgdaily.com/hardware-features/65123-on-arm-versus-x8
: Posted August 2, 2012 - 05:52 by Guy Wright
: It seems like everyone in the industry wants to compare ARM (and other
: variants of RISC processors) to x86 (and other variants of CISC processors).
:
For example, analysts ask, can Intel muscle it’s way into the mobile
: market? Can ARM sneak in the back door of the tablet, laptop, or even
: desktop markets? Who is faster, more powerful, cheaper, uses less power,
|
|
