Energy-efficient job stealing for CPU-intensive processing in mobile devices

Abstract

Mobile devices have evolved from simple electronic agendas and mobile phones to small computers with great computational capabilities. In addition, there are more than 2 billion mobile devices around the world. Taking these facts into account, mobile devices are a potential source of computational resources for clusters and computational Grids. In this work, we present an analysis of different schedulers based on job stealing for mobile computational Grids. These job stealing techniques have been designed to consider energy consumption and battery status. As a result of this work, we present empirical evidence showing that energy-aware job stealing is more efficient than traditional random stealing in this context. In particular, our results show that mobile Grids using energy-aware job stealing might finish up to 11 % more jobs than when using random stealing, and up to 24 % more jobs than when not using any job stealing technique. This means that using energy-aware job stealing increases the energy efficiency of mobile computational Grids because it increases the number of jobs that can be executed using the same amount of energy.

Appendix: Simple energy aware scheduler (SEAS)

The SEAS [44] is a scheduling algorithm for mobile Grids that is designed to perform scheduling along with as few estimations, such as device estimated remaining battery, as possible. The SEAS is a centralized scheduler, i.e., all the mobile devices that are considered by the scheduler must be connected to a central server which is called proxy. Basically, the proxy receives a job execution request and assigns the job to a mobile device. In order to select a mobile device, it ranks them according to which might assign more resources per job. For a mobile device $m$, this value is calculated as follows:

$$\begin{aligned} \text{ Resources} \text{ per} \text{ job}_{m}=\frac{\text{ estimated} \text{ uptime}_{m}\times \text{ benchmark}_{m}}{\text{ number} \text{ jobs}_{m}+1} \end{aligned}$$

(6)

where estimated uptime$_{m}$ is the estimated uptime for the mobile device with the remaining battery power, benchmark$_{m}$ is the value obtained using some benchmark that represents the MIPS (Million Instructions Per Second) the device is able to perform, which in scientific computing might be the Linpack or the SciMark 2.0 [43], and $number\, jobs_{m}$ represents the number of jobs assigned to that particular device. This function adds one to the number of jobs because it calculates which would be the node rank if a new job is added to it.

The only estimation the SEAS needs is each mobile device remaining uptime. The proposed estimation algorithm is based on the fact that battery APIs are event-based and the battery information is reported as a discrete variable. Examples of this are the iOS,⁹ Android¹⁰ and ACPI¹¹ battery APIs. A basic way of estimating remaining uptime with this event system is assuming a lineal discharge rate. Therefore, it is possible to calculate the discharge rate when two consecutive battery events happen. For two events $i-1$ and $i$, the discharge rate $dr$ can be calculated as follows:

The only estimation the SEAS needs is each mobile device remaining uptime. The proposed estimation algorithm is based on the fact that battery APIs are event-based and the battery information is reported as a discrete variable. Examples of this are the iOS, Android and ACPI battery APIs. A basic way of estimating remaining uptime with this event system is assuming a lineal discharge rate. Therefore, it is possible to calculate the discharge rate when two consecutive battery events happen. For two events $i-1$ and $i$, the discharge rate $dr$ can be calculated as follows:

$$\begin{aligned} dr=\frac{c_{i} - c_{i-1}}{t_{i} - t_{i-1}} \end{aligned}$$

(7)

 

where, $c_{i}$ and $c_{i-1}$ are the battery charge reported by the events $i$ and $i-1$, respectively. $t_{i}$ and $t_{i-1}$ are the times when these events occurred. Therefore, the remaining uptime $ut$ might be estimated as follows:

$$\begin{aligned} ut=\frac{c_{i}}{dr} \end{aligned}$$

(8)

However, the discharge rate is actually not lineal [48] and hence the estimation heavily varies from event to event. Thus, the SEAS uses a modified version of the estimator that returns an average remaining time instead of returning the previously defined remaining time. This average is calculated using the estimated uptime, which is defined as the current uptime plus the estimated remaining time as defined above. Therefore, the new estimated remaining time is the average estimated uptime minus the current uptime. Algorithm 3 describes how the remaining time is calculated. According to [44], this algorithm tends to work better over time and is suitable for the SEAS purpose.