I wouldn’t call that a problem at all. To get to the roots of the subject, we need to discuss virtual cores and HyperThreading. Intel Atom processors are intended to be low power, low performance and low cost solutions for the netbook market. To achieve the best performance to power-consumption ratio, engineers at Intel had to come up with some ideas you would not think of normally.

One of these ideas was HyperThreading, which isn’t a new idea at all to be quite honest. HyperThreading has been around since Pentium 4 processors or about 5-6 years. It was a way to enhance multi-task performance against the then formidable Athlon XP Barton processors. Intel had not thrown the whole concept out, but they had no time or intention to implement it in Core 2 Duo chips, so it kind of sank like forgotten buzzwords usually do.

Along came netbooks and EEE PCs. Asus made the category so popular that Intel decided to make a processor, which can be installed in low-power portable devices. The segment at that time was ruled by ARM processors, which Intel did not like for obvious reasons. There was no x86 capable processor that could keep up with the requirements of ultra portable netbooks and tablet PCs, so they decided to put some effort into making one.

That’s when the Intel Atom series CPUs were born. One of the first features to debut in Atoms was Hyper-Threading. It was a way to squeeze more performance out of the chip than the implementation costed in power. It gave more than one per cent extra juice for one per cent increase in power consumption so they obviously went with it.

How Does HyperThreading Work?

I’m sure most of you have a basic understanding of the components of a processor core, but here is a crude explanation for those who don’t. Processors have an arithmetic unit, which does one thing very, very quickly. It adds numbers. That’s all it does, so there are some additional parts to make sense of the data stream the ALU processes.

The pipeline prioritizes and queues data in a way that makes the best use of the arithmetic-logical unit. The job of the pipeline is to keep the ALU busy at all times. To do that, it needs a constant stream of relevant variables and memory content.

Because the processor does dozens if not hundreds of cycles by the time it could get some information from the memory, there are some registers that keep the most important pieces of information at hand at all times. When you use a program, the processor determines (takes an educated guess, so to speak) what the ALU will need further down the road and fetches it before it runs out of figures to play with. As long as there is only one piece of software running, it all works very well, and the arithmetic unit can be kept busy.

As soon as you run two pieces of software, the processor will have to switch between them back and forth. It seems as though you’re using multiple programs at the same time, but a single core processor can work with only one at any given time. In reality, it switches between applications so fast that you perceive them to be running simultaneously.

When the CPU switches to another application, it needs to empty its registers and cache because it needs to work with different parts of the memory and it requires different sets of data. Flushing the cache and fetching new information takes a lot of time, and that’s where HyperThreading enters the scene.

Hyperthreading technology doubles the registers and when the operating system asks, it lies that the processor has two physical cores. It makes the operating system prioritize and organize threads, programs, in a way it would for two separate processors.

Even though there is only one computing unit inside the processor core, hyperthreading gets data for two programs at the same time, so when the pipeline needs stuff from the other program, it doesn’t have to go all the way to the memory to get it. The data required will be available right in the registers and the cache, because the operating system provided it, thinking it feeds two different processors.

Benefits of multi-threading in Atoms

Since the registers don’t really use much processor space (the registers can be made out of very few transistors, compared to other functionalities of the CPU), they don’t use much power. For this reason, there are two sets of them in a hyper-threaded atom processor.

The quicker switching between threads gives a good 5 to 20% extra performance when working with multiple programs, but the implementation of the technology barely increases power consumption.

When two cores are being reported to the operating system and you know there should be only one, it’s because of HyperThreading. It’s a really smart way of increasing performance in Atom Processors, and it’s a good thing to have In some cases it may lower single-thread performance by up to 5%, but that’s hardly something you would notice, even with benchmarks.

Atom N550 processors will show up as four different processors, but it’s the same deal with the slight difference that it’s a dual core processor with HyperThreading on each one.