Share

tweet



This is the first part of a story on how marketing affects our perception of the world of mobile gadgetry. Help yourself with a generous portion of eyes-opening facts and statistics. Bon appetite.

The mobile gadgetry market is facing the stage of development when radical innovations happen once in a blue moon, while natural demand in selling smartphones and tablets for the companies to keep afloat didn’t evaporate. So if you consider the emergence of processors with eight cores, high resolution HD screens, 20-megapixel cameras and gigabytes of RAM to be technical progress, then welcome to the world of rigid and merciless marketing and money making.

Multi-core processors hysteria

In May 2005, Intel released its Pentium D x86-64 processor, which was the first dual-core processor for personal computers. Two years later, dual-core processors have settled a standard, and replaced the idea of ​​increasing the clock frequency with the concept of ​​installing more processors on a single chip. Three years ago mobile chips manufacturers followed the idea, and today we have a four cores de facto standard in mobile gadgets, which, apparently, will soon be replaced by the installation of six and eight-core processors. It may seem that everything is fine, but actually, there is practically no point in such contour.

To understand why multi-core processors are not needed in the mobile technology, we have to dedicate our attention to the invention itself. Originally multiprocessor systems were used exclusively for servers, where they really could raise performance significantly. A boost in performance was conditioned by two major aspects: a true to type server has to deal with sky-high loads and calculation operations often prevail over the input-output operations (this is also typical for different applications designed to calculate a trajectory of a missile or assist in finding a cure for cancer).

It means that the tasks executed on multiprocessor systems, could have been efficiently parallelized. For example, the task of searching for a string in a large amount of data could be split into two or more subtasks simply by making multiple copies of tasks to look for the necessary data. Splitting of tasks on dual systems contributes to a resolution speed doubling. But even in this case minor losses would be monitored due an inability to access memory instantly (we have two CPUs, and one DDR entity) – meaning that a random task is waiting when another one finishes writing or reading memory. However, thanks to the processor’s cache, the lightning speed of memory and DMA block these losses are almost insignificant.

Now let’s consider a more complicated example and have a look at the server that receives requests over the network, and then reads data from the disc and sends it back. This task can also be parallelized, but the time loss would be greater now, and double productivity increase will not be achieved. The subtasks will block each other when accessing the hard disk (which is very slow in comparison with RAM) almost permanently if you call the various kernel functions. Allowing for the possibility that the server emits some sounds, displays something on the screen and takes pictures every time it is accessed apart from its primary mission, the performance boost would have dropped to a maximum of 20%.

Now let’s study the way a typical smartphone is functioning. Mentioned below are the typical features:

Consistently low CPU load with occasional bursts: the system itself and the applications are designed not to use CPU intensively to reduce energy consumption.

Prevalence of input-output operations over calculations: the applications are designed to be stored in stand-by mode, update screens and send/receive data over the network.

A broad variety of integrated mechanisms, sensors and other components which can be accessed by a particular mechanism only.

There is an extremely tiny number of applications available in the market that can distribute the load on multiple processors/ cores efficiently.

In such conditions, the system simply cannot use a multi-core processor effectively, in fact, it doesn’t need it at all. Due to an extremely low CPU load and constant blocking of tasks when accessing the equipment, a single core is more than enough to conduct its business perfectly (as long as one task is blocked, the second one is handled by the processor). One of the few examples where the second core could have been useful is GUI acceleration: in such scenario one core could have been engage in updating the display, while the second could have performed the other tasks. However, an overwhelming majority of modern smartphones utilizes quite powerful GPUs.

Another possible option of tapping the second core lies in running a variety of background tasks, e.g. multimedia files indexer on the memory card or the apps installer. In this case, the smartphone could do away from rare friezes, which happen when some background service suddenly wakes up at the most inopportune moment (the way, incidentally, Android 4.X runs).

Another possible thing that could have loaded all the four or even eight cores is nothing but a resource-intensive game. The only problem is that such games haven’t managed to pave their way to the shelves yet. Frankly speaking, correct parallelization in games is a tough mission, while it is quite obvious that mobile platforms have a secondary priority for game developers still, so it is not highly likely that we will face optimization efforts to load for four (not to mention eight) cores, in the nearest future.

To sum up, integrating two cores in a mobile device is more than sufficient at the moment: while the first core can be used by a running application, the second one could handle various services that occasionally wake up to check memory card, receive data from the network or reset file system cache. What do neoteric gadgets do with other two or even six cores is still unclear. Even if the system deals with start-intensive tasks they remain untapped: video players use codecs for decoding GPU, games utilize one or two cores, while a lion’s share of other applications is too primitive to demand a multi-core processor for smooth operation.

And yes, even if you can see in that all the cores are loaded heavily, it does not necessarily mean that a need in the cores is that acute. Actually, it is nothing but a consequence of modern operating systems design, when tasks are divided automatically to ‘distribute’ the load.

64-bit processors – the appropriateness of use

Perhaps, some day multicore processors will come in handy for specific tasks performed on smartphones, but whether a smartphone needs a 64 bit processor is a big question. The fact should be underlined that arguments that justify the integration of 64-bit processors in desktop PCs, do not justify their use in mobile gadgetry area.

To find out the truth, let’s plunge into the server market once again. 64-bit processors were for invented two simple reasons: it guarantees enviable efficiency when working with fractional numbers, which can be useful for the meteorite trajectory calculation and allows addressing 16 exabytes of memory which is a good result when it comes to meteorite threat. In addition, 64-bit technology removes the barrier of 4 GB of visible RAM, characteristic for 32-bit processors.

Clearly, a smartphone is not likely to be ever used for such calculation, but extra memory will never hurts. And this is where the real fun begins. The fact that the problem of large amounts of memory was eliminated by ARM in Cortex-A15 architecture, which gave birth to Tegra 4, Exynos 5 and OMAP430.

In these chips LPAE (Large Physical Address Extension) module for addressing memory could be used that extends the bus to 40-bit, mitigating the limitation on the amount of memory up to 1 terabyte. LPAE supported the operating system (and in Linux it has been implemented long time ago) allows you to use all the memory, but limits the address space of each process to four gigabytes, which is hardly a silver bullet for servers that require more space for storage of intermediate results and caches, but certainly a panacea for smartphones.

In other cases 64-bit processors and applications create more problems rather than solutions. For example, the volume of an application when compiling a 64 -bit version is increased on average by 20 %, and operating system developers are forced to deal with dozens of technical issues. Honestly, our attempt to find more opportunities granted by 64 bit technology in mobile devices has resulted in a failure. However, you can still calculate trajectories of meteorites and transcoding 54GB+ videos via your smartphone.