master

February 20, 2012

Low Power Techniques in multicore systems based in ARM architecture (Part III)

Ok so I promised to show you the test I’ve done with pandaboard to test CPU HotPlug technique right? So come on… I’ve talk before about Pandaboard development board, and if you didn’t hear about it before, now it’s a good time. Pandaboard ships with an OMAP4 4430 chip, with dual core ARM Cortex A9  processor @1GHz, 1 GB low power RAM and Bluetooth 2.1, Ethernet, Wireless, HDMI… as you can see, great connectivity and great details for such a little device.

Pandaboard

For the tests, I set up two different scenarios, one playing video file on SD card and the good one with  an Apache Web Server on Pandaboard, and running several loads with JMeter to see how it performs. As OS I used Ubuntu 11.04 with kernel 2.6.38-1208-omap4, and to measure the power consumption, I had to use a multimeter (with USB connection, what a great idea!!) because at the moment it seemed impossible to get voltage or power values directly from the board.

Test Environment with PandaBoard and Digital Multimeter

Here you can see the results of playing the same video file, using 2 cores and using only 1 core, after having the second core disabled by CPU Hotplug. As you can see, power consumption is lower, but not as much as to prefer to use 1 core instead of two, and specially for playing video.

Power consumption results for video playing test with 1 and 2 cores

Maximum Power consumption during video playing

The next tests are more interesting. These are the tests done with Apache Web Server and JMeter load testbench. In the next images, you can see the power consumption of the Pandaboard using 1 or 2 cores, with different threads values: 5, 10, 25 and 50. Those are threads or connections opened on Apache Web Server. For the application used for the tests, GLPI (www.glpi.org), there was also a MySQL on Pandaboard, but as the configuration was the same for all the tests, the important part is the load behaviour on Apache.

Jmeter test with 5 threads / connections using 1 and 2 cores

Jmeter test with 10 threads / connections using 1 and 2 cores

Jmeter test with 25 threads / connections using 1 and 2 cores

Jmeter test with 50 threads / connections using 1 and 2 cores

As you can see in the graphics, using only 1 core power consumption on Pandaboard was near half of the power consumption when using 2 cores, even if for a higher number of threads, HTTP requests delay was higher. After doing this test I reach the following conclusion / question: It’s better to do the job with less power but more time, or faster but with more power consumption? When I was thinking about it and about the behaviour or CPU HotPlug, I realized that I could try to use it in a dynamic behaviour, so instead of processing all jobs with 1 or 2 cores, it would be possible to enable or disable the second core of ARM Cortex A9 processor using the system load. With this “dynamic” core management, we can enable the second core when system load is too high for only 1 core, and even if the power consumption would raise, the results of doing this could be interesting. The following test are showing this particular behaviour, and you can see how the yellow line which represents Dynamic Core Management, performs compared to the same system load with 1 and 2 cores.

Jmeter test with 5 threads / connections using 1 and 2 cores and Dynamic Core Management

Jmeter test with 10 threads / connections using 1 and 2 cores and Dynamic Core Management

Jmeter test with 25 threads / connections using 1 and 2 cores and Dynamic Core Management

Jmeter test with 50 threads / connections using 1 and 2 cores and Dynamic Core Management

As you can see, using a medium system load, the power consumption obtained using our script for Dynamic Core Management performs as the 1 core execution for lower loads, but as the 2 core execution when system load becomes higher. The benefit here could be in medium or more detailed system loads, when power consumption could be lower then using 2 cores, but with better performance than using only 1 core. In terms of Maximum Power Consumption, you can see how it goes in the four scenarios tested, and is very interesting to see how for the test with a higher number of threads, the use of our script enabling the second core has a higher power consumption than the same case with 2 cores.

Maximum Power consumption for 5 threads

Maximum Power consumption for 10 threads

Maximum Power consumption for 25 threads

Maximum Power consumption for 50 threads

After this last result, where power consumption using the script that enables the second core is higher than using 2 cores, I was curious of such behaviour, so I decided to test and measure only the period when CPU Hotplug enables (CPU UP) and disables (CPU Down) the second core. After doing those tests, I realized that as the studies showed, the use of CPU HotPlug technique was not free in terms of power consumption, and here you can see how the power consumption behaves during the process of CPU up and CPU down.

Maximum Power activating the second core with CPU Hotplug

Maximum Power disabling the second core with CPU Hotplug

After all these test and the research done about CPU Hotplug, the conclusion is that could be a interesting technique for embedded devices, when idle time and battery saving are really important (Are you thinking on mobile phones?? Yes, they meet those conditions).

But for other scenarios this technique is not the best as we have seen, and there are different studies about a “low power scheduler” for ARM multicore systems or similar techniques without the power consumption overhead present in CPU HotPlug activating and disabling the second core. Examples of those techniques are sched_mc and CPU Set developed by Linaro Power Management Working Group.

The most interesting thing is not only the grow of ARM based systems, and not only on embedded devices, but also how ARM processors performance is increasing thinking also in power management, essential for embedded devices.

January 29, 2012

Low Power Techniques in multicore systems based in ARM architecture (Part I)

Hi all,

This is my second post, and as I promised, I’ll talk about my Master Thesis about Low Power Techniques in multicore systems based in ARM architecture.

This thesis was the end of a Master Degree started two years ago, when I became (finally!) a Computer Science Engineer and I was looking for a good job opportunity. As this opportunity was a little lazy to came, I decided to start a Master Degree, with Embedded and Reconfigurable Systems as mayor and Computer Networks and Technologies as minor specializations.

I decide to study Embedded Systems because it was the most interesting path for me, and I was a little curious about embedded systems, FPGAs and this kind of devices.

In the differente subjects we’ve worked more with VHDL and FPGAs, Xilinx, PowerPC, but most of all related to VHDL – FPGAs. Even if I liked the different subjects and labs, I was more interested in Embedded Linux, so finally, when I had to choose the subject for the thesis, I was sure that Embedded Linux would be a great subject to study. Two main reasons were that I would have to write my thesis while working  in very different area, and so I’ll have to write and prepare it by myself at home in my free time.

During the master degree, I discovered the world of embedded Linux with beagleboard or gumstix, and also played with a beagleboard like board called IGEPv2, based in an OMAP3 chip.

While I was struggling myself to decide the final subject of the thesis, I suddenly had THE idea: buying a Pandaboard and doing something related with low power and power management in Linux. The pandaboard development board has an OMAP4 chip, with two ARM Cortex A9 processor, so I thought it could be a good idea to study and to do some research about power management on a dual core ARM board.

If you don’t know what a pandaboard is… Well… I now it’s embarrassing but you can check it here: http://www.pandaboard.org 🙂

So once I bought the Pandaboard and after some days got it at home, I started to play with it, trying and choosing the best distribution for my needs. I tried first with Debian, but after some time I realized that Ubuntu for ARM was doing a good job, and would contain more recent packages and kernel, so I installed Ubuntu ARM 10.04.

Now the last version is 11.10, but I did my developments and research on 10.10. (https://wiki.ubuntu.com/ARM/OMAP).

Once I had the system working, with HDMI, wireless connection, usb mouse and keyboard, I began to study and find how can I retrieve power management information from the system and also interact with it.

If you dont’ know it, there is a great project sponsored by IBM, Canonical, ARM, Samsung, Texas Instruments or Freescale, called Linaro (www.linaro.org), and its mission is to create a common ecosystem for ARM based systems, in order to organize and merge the different projects and work done for all ARM embedded devices. With this, they said that manufacturers could achieve faster time to market, and also would mean easier work for developers and integrators of this products.

So the great about Linaro are the Linaro Working Groups, different Teams that work with a different mission to achieve the proposal of Linaro Foundation. Thera are several Working Groups, for UX / Design, for Kernel related work, for Graphics section and the one I’ve most appreciated, the Power Management Working Group (WG).

I spend some weeks in research  different posibilities to manage power consumption in Linux and most specifically in Embedded Linux, but most of them were designed  for systems with only one processor. One day I came back to Linaro Power Management Group and found a new technique designed in particular for multicore systems, and so I decided to try it on my Pandaboard.

In my next post, I’ll cover the different techniques I found for power management in Linux and the one I choosed to test and to study more in detail, with the different results obtained during the research.

Thanks for your time reading here! 🙂

MB