Archived

big.LITTLE processor's power-performance scaling (2014~2017)

Power-efficiency is one of top-most requirements for mobile devices because they run with limited battery. However, lowest power consumption cannot meet the application performance; for real-time rendering in 3D gaming graphics, camera encoding/decoding, and CPU-intensive intelligent services such as contextual search, speech recognition, etc. That is, power consumption-performance have to be flexibly controlled, so that we can minimize power consumption, meeting the performance requirements, and that we can maximize performance for given power budget. Although CPU takes only 15~20% of power consumption, it is still a huge proportion. In addition, CPU is one of the most important hardware components in performance. Thus, we focus on power-performance scaling of CPU.

Rather than traditional approaches for power-performance scaling, such as DVFS (dynamic voltage and frequency scaling), multi-core scaling, single-ISA heterogeneous multi-core processor architecture (SI-HMP) draws attention recently. By compositing low-power CPU cores with high-performance CPU cores, we can best leverage power-efficiency and performance on demand. In addition to heterogeneity, the cores use single-ISA, so that one can flexibly migrate tasks from low-power core to high-performance core without re-compilation. As an example, ARM developed big.LITTLE platform, that includes low-power cores (or little cores) and high-performance cores (or big cores), at the same time.

We revisit the power-performance scaling law in more recent hardware platform, presenting the feasibility of big.LITTLE platform. In big.LITTLE platform, we can scale down power consumption by utilizing little cores instead of big cores. In addition, we can scale up performance by activating big cores. Compositing with DVFS, multi-core scaling, big.LITTLE can provide important trade-off relationship between power and performance.

Software testing automation for LG smart TV platform (2014) - Archived

Currently, we are focusing on software testing of embedded operating systems that run on smartphones, TVs, and daily gadgets including wearable devices. Software testing is an important software development process, particularly for consumer electronics. Once the end product is handed to end-users, it has to run for years with minimal maintenance cost. Thus, much effort has been consorted to the testing and debugging as well as developing new functionality.

Testing an embedded operating system is a big challenge because ad-hoc testing requires too much effort for large software such as an operating system. Thus, structured and planned testing is essential to keep test coverage. In addition, testing an open source operating system is difficult because it evolves continuously. Moreover, changes are made by people under different organizations at different layers. To preserve the compatibility with the upstream version, the OS developers have to keep track of the changes made at different layers, which is almost impossible to know at development phase. Accordingly, testing should be flexible enough to cover frequent changes at different layers.

Besides, recent mobile operating systems export some components to the user-level, protecting the proprietary intellectual assets. More often than not, source code for commercial products are strictly opened to very limited developers; thus, one should write code without exact understandings of the changes in another component's behavior. Accordingly, modifications at some components would badly affect another component. Though rigorous regression test methodologies are proposed, it is difficult to find such behaviors change, and their side-effects at development phase. To provide solid compatibility, the testing should alert the compatibility issues that could arise such side-effects.

To minimize the testing effort, we are developing a new software testing framework. Our framework supports planned, automatic testing for changing scenarios, and parameterized test cases. In addition, our framework is designed flexibly to work with the evolving software interfaces. Moreover, our framework reveals compatibility issues that are popularly raised from changed behaviors.