Emerging Trends and Challenges
Smart devices, such as smartphones and tablet computers have been steadily increasing in capabilities and performance. Modern devices commonly contain multi-core CPUs running at clock speeds well over 1GHz. For example, the Galaxy Nexus from Google contains a 1.2 GHz, dual-core processor with 1GB of RAM and other Android smartphones now have quad-core processors.
The increased performance of smart devices comes at a cost, however. Due to their mobility, smartphones and tablets run exclusively on battery power, so every increase in performance must be balanced with an increase in battery capacity to maximize the time between charges. The design of applications running on the device can also impact battery life, e.g., frequently sampling the GPS or making network requests can consume a significant amount of power.
To balance functionality with power consumption effectively, developers must understand various trade-offs. A key trade-off is between performance and battery life, as well as the implications of the application and infrastructure software architecture on power consumption. Functional requirements, such as minimum application response time, can conflict with power consumption optimization needs.
For example, a traffic accident detection application (White, Clarke, Dougherty, Thompson, & Schmidt, 2010) must be able to detect sudden accelerations indicative of a car accident. To detect acceleration events that indicate accidents, the application must sample device sensors and perform numerous calculations at a high rate. Conflicts occur between the functional requirements (e.g., the minimum sensor sampling rate needed to accurately detect accidents) and non-functional requirements (e.g., sustaining operations on the mobile device without frequent battery recharging).
Due to complex middleware, Operating System (OS), and networking layers, it is hard to predict the effects of application software architecture decisions on power consumption a priori, i.e., without actually implementing a design, which makes it hard to analyze the power consumption of design until late in the development cycle, when changes are more expensive (Kang, Park, Seo, Choi, & Hong, 2008). For example, a developer may elect to use HTTPS instead of HTTP to satisfy a security requirement by making communication between the application and server more confidential. It is currently hard, however, to predict how much additional power is consumed by the added encryption and decryption of data without actually implementing the system.
It is also hard to quantify the trade-off between power consumption and security, as well as many other design decisions. Moreover, certain design decisions, such as data transmission policies (e.g., should an application transmit immediately or wait for a specific medium like a Wi-Fi or 3G cellular connection) are hard to analyze early in the design cycle, due to their variability. For example, if an application only sends data intermittently, it may be beneficial to transmit small amounts of data over cellular connections due to the decreased power consumption of 3G cellular connection compared to Wi-Fi (Agarwal, Chandra, Wolman, Bahl, Chin, & Gupta, 2007). If a large amount of data must be sent, however, the total time required to transmit it over 3G may negate the benefit of using the less power consumptive connection. The cellular connection will take longer to transmit the data, therefore, which may in turn consume more total power than the Wi-Fi radio that can transmit the data faster.