I have a Asus Vivo RT tablet that has a 'quad core' Tegra 3 Arm processor. When I do some simple multitasking like opening two webpages at the same time, it becomes almost unresponsive. What does a 'quad core' arm processor actually mean and how is it different from a x86 quad core?
Best Answer +snaphat (Myles Landwehr) , 24 November 2013 - 01:33
One large, in general, difference is that ARM execution is simple, stupid, and in-order; where as, modern x86 is aggressive out-of-order execution. It cost energy and die space to have features like that so atoms until very recently were also in-order execution. Which is frankly, probably the largest reason why they ran like complete garbage compared to their i7 based counterparts. IIRC, it is only the newest atoms from this year that feature out-of-order execution in any form.
Another large different is the Instruction Set Architecture (ISA). Vaguely, these are the instructions that the processor executes. For example, additions or multiplications. ARM itself is largely considered to have a RISC architecture; where as, x86 is largely considered to have CISC architecture. RISC, stands for for reduced something something something architecture, and in general means that you have smaller instructions that do fewer things and that take very few cycles to execute. CISC stands for complex something something something architecture; and in general means you have more complex instructions that can do many different types of things. A side effect of this is that complex instructions can take more cycles.
For a quick example of this, consider the MOV instruction which is mnemonic instruction name meaning to copy data from one location to another:
In x86, you have a MOV instruction which can move data into registers to registers, from memory to memory, memory to registers, register to memory, or move a constant into a register (and probably move constants elsewhere, I don't remember off the top of my head). Moreover, there are even variations on the MOV instruction to do sign/zero extensions on top of just moving the data.
Whereas, in ARM, you have a MOV instruction that is designed to copy data into a register _only_ from another register or constant. If you wanted to copy data into or out of memory you would have to use completely separate load/store instructions. Moreover, it would in many cases take you multiple ARM instructions to do what a single x86 instruction can do. I'll give a small example of that also:
x86: mov $dst, $src arm: ldr R2, $src str R2, $dst Disclaimer: I didn't actually look up the syntax for any assemblies when writing this. This is just for demonstration purposes.
Now that isn't to inherently say that one architecture is better than another because saying that is just a needless argument. In reality, many of the things that a CISC architecture does translate into micro-operations that are quite similar to RISC instructions -- at least that is how x86 does it anyway. People who aren't really all that familiar with computer architecture tend to like to point out CISC and say it is bloated. Sure, in a sense it can be considered bloated because it carries a whole lot of baggage in terms of instructions and backward compatibility, but that doesn't make it slow or inefficient. It isn't as if with every iteration and addition to the architecture that Intel slows the rest of it down to a grinding halt... that is certainly not how architecture design works.
One final note is that I have heard very often that it takes a decade at least to create 'good' compiler capable of generating well optimized code for new architectures. The point of that is to say that it takes more than a good architecture to make fast execution. It takes good compiler support also.
- http://infocenter.ar...j/Cihcdbca.html (ARM MOV reference)
- http://research.cs.w...truggles-tr.pdf (RISC vs CISC performance study)
- http://en.wikipedia..../Sign_extension (for zero/sign extension reference)
Final Disclaimer: something something something is tongue in cheek.Go to the full post