Compute Intensive Code Offioading In Mobile Device Cloud Sajeeb Saha, Student Member, IEEE, Md. Ahsan Habib, Student Member, IEEE, Md. Abdur Razzaque, Senior Member, IEEE Green Networking Research Group, Department of Computer Science and Engineering, University of Dhaka, Dhaka-lüOO, Bangladesh Email:
[email protected]@
[email protected] Abstract-With the advancement of mobile computing technologies computation intensive mobile applications are also thriving in a rapid pace. Existing c10ud and c10udlet based solutions are not best suited for these applications in terms of response time and cost. A rampant technology to execute these applications is mobile device c1oud, where the compute intensive part of the applications are migrated to nearby powerful mobile devices for offioaded execution. In this paper, we pro pose an offioading decision making algorithm to select the appropriate devices for offioading. The emulation results of the proposed algorithm show that, our algorithm outperforms the relevant approaches in terms of application execution time.
I. INTRODUCTION
Mobile communication all over the world is increasing day by day. Few recent statistics show that around 2.1 billion smart-phone users, all over the world, are using various mobile applications [1]. These applications are estimated around 268.69 billion by 2017 [2] of which computation intensive applications like face recognition, reality augmentation, sensing and monitoring, online video games etc. are becoming very popular for mobile devices. However, execution of these applications on mobile devices, most of the time, is not feasible for various issues i.e. delay, energy, QoS etc. These issues have been addressed by many researchers with a general solution yclept Computational Offloading [3] . In computational offloading, compute intensive modules of the software application is migrated to cloud server for faster execution. In cloud offloading method, the distant enterprise cloud is used for offloaded execution, that are explored in [46]. In this method, the mobile device or the remote cloud determines which portion of the code is to be offloaded for execution in the cloud. Though the cloud offloading technique significantly reduces the execution time, some realtime and latency sensitive applications cannot tolerate it due to excessive communication delay between cloud provider and mobile devices [7, 8]. The problem is addressed by introducing cloudlets [7] which are smaller version of the enterprise cloud that contain limited amount of resource-rich computation entities placed at different locations for executing offloaded program-segments. Since the cloudlets are in the vicinity of mobile devices, the data transmission latency gets reduced significantly compared to distant enterprise cloud environment. However, the performance of cloudlet offloading degrades significantly due to the increasing penetration of
978-1-5090-2597-8/16/$31.00@2016 IEEE
mobile devices and contention between mobile devices under a single cloudlet having limited resources. These issues lead to the third approach called Mobile Device Cloud (MDC) [8- 10], which employs the unused resources of the nearby available mobile devices to execute the application of a particular user. In [9], the authors proposed a powerful job structure to speed-up the computation and conserve energy. An algorithm was also developed by them for task dissemination and monitoring of the offloaded tasks. In [8] , the authors implemented an emulation testbed which showed the effectiveness of MDC compared to remote cloud or cloudlet based code offloading solutions. A generic architecture for computational offloading to heterogeneous devices including cloud, cloudlet and mobile device cloud has been proposed in [10]. The architecture provides ideas to maximize the computational gain of a mobile device by minimizing response time and energy while maximizing network lifetime. All these works present the benefits of mobile device cloud technology that exploits the resources of other mobile devices. However, none of the works considers the parallel execution while maintaining the dependency between the modules in order to speed-up the execution of the application. Furthermore, in [11], the authors show that, most of the time mobile devices stay in idle state whereas other devices can't afford to execute large applications by their li mi ted processing powers. It becomes impossible due to the limited computation capacity of mobile devices to execute real-time multimedia applications. To do so, we can aggregate the idle computation power of the nearby mobile devices under an MDC to execute a compute intensive application. However, due to the mobility, MDC itself issues several challenges including determination of portion of code to be offloaded and where to offload, maintenance of connectivity among mobile devices, ensurance of device availability in terms of minimum battery energy, etc. In this paper, we intent to exploit the Mobile Device Cloud technology to formulate an algorithm for distributed and collaborative computation that provides better application execution time. The main contributions of our work are summarized as folIows : • We develop an algorithm for assigning software application modules to available mobile devices so that the overall execution time of the application is minimized.
436
Network Access
Donee Cloudlct
Fig. 1.
DOllor
Code offioading architecture
• A testbed experiment environment is developed and the results show the effectiveness of the proposed algorithm compared to the state-of-the-art works. The remainder of the paper is organized as folIows. An explicit insight into our proposed algorithm is presented in Section TI. Section III discusses on the results obtained from performance evaluation and finally, we conclude the paper in Section IV. 11. COMPUTE INT EN SIV E CODE OFFLOADING Mobile device cloud consists of heterogeneous set of devices including smart-phones, pads/tabs, laptops, palmtops, wearable devices like glass, watch etc. All these devices exhibit different set of characteristics in terms of network connectivity, application execution and energy consumption. Generally, the computing resources of mobile devices remain idle in most of the time in a day. This idle power can be used as a computing power source to a resource constrained device which has a high computing task to execute. In this context, we can consider a mobile device as a cloud service provider which has a virtual machine (VM) instance that can be provisioned to execute the applications of other mobile devices. Each mobile can set a fixed amount of resources (CPU, storage, Memory etc.) to create a VM instance. If the mobile device chooses to act as a VM only then the resources can be used by other mobile devices in the vicinity. The shareable amounts of resources are flexible so that the mobile device can create different size VMs based on its current idle resources. A. Code Offloading Architecture
Usually computation intensive applications are hard to execute on the mobile devices and if executed on the mobile devices the batteries drain out quickly as it requires a large amount of CPU cycles. If the application is apportioned and offioaded to nearby cloudlets or other mobile devices, then the whole application can be executed in much less time while saving a considerable amount of energy. To facilitate the collaborative execution of different modules we provide an architecture which is shown in Fig. I, where several mobile devices are connected through a wireless interface (Wi-Fi). It is a three-tier architecture with user mobile device (donee) at tier one, cloudlet at tier two and service providing mobile devices (donor) at tier three. The donee device has a compute intensive task to execute but is unable to execute it due to constrained resources. So, it communicates with the cloudlet at tier two to make an offioaded execution of the application. The cloudlet
Fig. 2.
Execution [ree for modules of an application
then communicates with the connected donor devices at tier three and selects the appropriate devices to distribute the tasks for execution. The cloudlet coordinates the distribution of tasks to donor devices, accumulation and sending the result back to the donee device because the decision making and mapping of the modules into different donor devices is a complex process and requires both high computation and energy. Running this decision making algorithm on the donee device might avert the gain of the overall process. On the other hand, the cloudlet is equipped with rich computation resources with line power supply, making it suitable to execute the decision algorithm. B. Offloading Decision
We consider each user application as a set of M processing modules, each of which performing a specific operation of the application. The execution flow of the modules forms a rooted tree, as shown in Fig. 2. The directed edges between the vertices of the tree defines the dependency between the modules. A module cannot be executed until the execution of its parent is completed. On the other hand, all the modules in the same dependency level can be executed in parallel. The total execution time of the offioaded modules defines the performance of the application . As all the modules in a dependency level are executed in parallel, the module that takes maximum time for execution is ultimately the level execution time (Ctime) which covers the execution time of all the modules in that level. Hence, greater number of modules in a dependency level decreases the overall execution of the application . The total execution time of the application is the summation of execution times of all the levels (L) and data transmission times between the modules. To determine the appropriate devices for the offioaded execution, the donor devices must have to fulfill the selection criteria. These criteria includes device computation power, energy (E) , data rate (B) and associativity time (A). A device will be selected as a donor if it can execute the task in less time compared to the donee device and it maintains a minimum data-rate (ß) with the cloudlet. Moreover, it must have sufficient energy (a) to execute the task and send the result to the cloudlet. During this execution (etime) and communication (ttime) time the device will be connected to the same cloudlet. Hence the device should have a minimum associativity time At". Algorithm I describes the sequence of steps for the mapping of modules with the appropriate devices from the available list of devices N.
20161EEE Region 10 Conference (TENCON) - Proceedings ofthe International Conference
437
Aigorithm 1: Compute intensive code offloading in MDC Input : L , M ,N , Bk,Ck Output: A = {( m, k)}, allocation set of module m E M to device k E N 1 for i E L do 2 for m E M do 3 for k E N do 4 if (k =1= busy && ck > a && Bk > ß && Ak > At/1) then 5 I CUme +- elime + tUme; 6 end 7 end 8 minlime +- min(Clime ) ; if (minlime < localtime) then 9 A +- (m ,k); set k +- busy; end
10
12
end end
13
return A;
11
addition requires a large amount of time as these are represented in strings. Similarly, generating prime numbers with large range are also compute intensive and hence requires a lot of computation. For this reason, we have divided the whole task into several subtasks which are given to different devices for offloaded execution. In OUf experiment, the prime number problem generates primes between 1 and 300000 where as the big integer addition problem computes summation from 1 to 1000000. In both cases, the applications are divided into modules between 2 to 6 where the first module is always executed on the user device and the rest of the modules are executed on the donor devices. To be a candidate donor for offloading, the devices must have a signal strength of -80db and 40% available battery power. To formulate the dependency, we have made several dependency levels in the modules for both application. The considered dependency levels between the tasks are depicted in Fig. 3.
IH. PERFORMANCE EVALUATION This section describes the experimental testbed and the outcome of the emulation works.
(a) Two Level Fig. 3.
A. Experimental Testbed
Since no practical simulation environment is available yet, we evaluate the performance of our proposed framework through an emulation testbed by implementing an Android application with a number of heterogeneous mobile devices. All the mobile devices are connected to a central Laptop which acts as the cloudlet in oUf scenario. All the devices are connected through Wi-Fi as it is the standard technology for multiple device communication in a local arena. Table I shows the parameters of different devices that are used in the emulation works: TABLE I DEVICE SETTINGS
Device
Model
OS Version
RAM
CPU
Laptop
ASUS ZenBook UX303LN
Windows LO
8GB
Core i55200U 2.20GHz
So ny LTI8i
Android 4.0.4
512 MB
1.4 GHz Scorpion
Symphony T8Q
Android 4.2. I
1GB
Quad-core 1.2 GHz Cortex A7
Walton Primo X2mini
Android 4.2. I
1GB
Quad-core 1.5 GHz Cortex-A7
(cloudlet)
Cell Phone (donee)
Tablet
PC
(donor)
Cell Phone (donor)
To formulate our compute intensive application we have used big integer addition and prime number caIculation problems as experimental prototypes. Generally, the big integer
438
~ ~ ~
(b) Three Level
(c) Four Level
Simulated dependency levels of the application
B. Results and Discussion
In this section, we discuss the performance of our proposed algorithm with local execution and the benchmark solution named MDC implemented in [10]. To evaluate the performance, we have used execution time as the performance metric, which is measUfed as the total execution time of the modules along with their communication times. We have varied the number of dependency levels and parallel number of modules to observe how they affect the completion time of the application . The Fig. 4 shows the impact of different dependency levels amongst the application modules on execution time. The results show that, the local execution time remains constant for all the dependency levels since the modules are executed in sequential order. However, the MDC and OUf proposed algorithm experience linear increase in execution time with increasing number of dependency levels both for big integer and prime number generations, which is also expected theoretically. Furthermore, the execution time is much less compared to their local counterparts. It is also observed that the proposed algorithm requires slightly less time to produce results compared to the MDC system due to prioritization of devices having higher signal strength in OUf proposed scheduling algorithm.
2016 IEEE Region 10 Conference (TENCON) -
Proceedings ofthe International Conference
160
160
140
140
120
120
:[100
I100
Q)
,§ c:
Q)
80
=c:E
g 60 i3 ~ w
20 0
~
60
w
40
lil >
< w 40
20
o
6
(a) Big integer
120 U ~100 c:
4 5 Number of devices
160
140
=~
3
234
5
Number of dependency levels
20
6
0
(b) Prime number Fig. 4.
2
Fig. 5.
[4]
IV. CONCLUSION In this work, an offloading decision making algorithm has
been developed for compute intensive mobile applications based on mobile device c1oud. The results show that, our proposed algorithm outperforms the state-of-the-art works in terms of execution time. In future, we will explore the mathematical modeling of the proposed work to fine tune the decision variables that impacts the QoS of applications.
[5]
[6]
ACKNOWL EDGM ENTS
This work is supported by agrant for the "Research Fellowship (2015-2016)" funded by the Information and Communication Technology Division, Ministry of Posts, Telecommunications and Information Technology, Government of Bangladesh. Dr. Md. Abdur Razzaque is the corresponding author of this paper.
[7]
REFER ENCES
[8]
Internet trends 2015-code conference. Glokalde, 1(3), 2015. [2] Mobile App Usage Statistics Overview. http://www.statista.com/topics/ I 002/mobile-app-usage/, Access Date: 19/05/2016. [3] Karthik Kumar, Jibang Liu, Yung-Hsiang Lu, and Bharat Bhargava. Asurvey of computation offloading for mobile
4 5 Number of devices
6
(b) Prime number
Impacts of dependency levels
As the number of devices is increased in a level, the total execution time of the application is decreased in MDC and our proposed scheduling algorithm, as shown in Fig. 5(a)(b). The proposed algorithm shows the minimum execution latency due to achieving higher parallelism in executing the modules.
3
[I] M. Meeker.
[9]
Impacts of parallel execution
systems. Mobile Networks and Applications, 18(1):129140, 2013. Mike Jia, Jiannong Cao, and Lei Yang. Heuristic offloading of concurrent tasks for computation-intensive applications in mobile c10ud computing. In Computer Communications Workshops (INFOCOM WKSHPS), 2014 IEEE Conference on, pages 352- 357. IEEE, 2014. Zixue Cheng, Peng Li, Junbo Wang, and Song Guo. Justin-time code offloading for wearable computing. IEEE Transactions on Emerging Topics in Computing, 3(1):7483,2015. Mahbub E Khoda, Md Abdur Razzaque, Ahmad Almogren, Mohammad Mehedi Hassan, Atif Alamri, and Abdulhameed Alelaiwi. Efficient computation offloading decision in mobile c10ud computing over 5g network. Mobile Networks and Applications, pages 1- 16, 2016. Mahadev Satyanarayanan, Paramvir Bahl, Ramon Caceres, and Nigel Davies. The case for vm-based c10udlets in mobile computing. IEEE pervasive Computing, 8(4):14- 23, 2009. Abderrahmen Mtibaa, Khaled A Harras, and Afnan Fahim. Towards computational offloading in mobile device c1ouds. In Cloud Computing Technology and Science (CloudCom), 2013 IEEE 5th International Conference on, volume I, pages 331- 338. IEEE, 2013. Cong Shi, Vasileios Lakafosis, Mostafa H Ammar, and Ellen W Zegura. Serendipity: enabling remote computing among intermittently connected mobile devices. In Pro-
2016 IEEE Region 10 Conference (TENCON) - Proceedings ofthe International Conference
439
ceedings of the thirteenth ACM international symposium on Mobile Ad Hoc Networking and Computing, pages 145- 154. ACM, 2012. [10] Abderrahmen Mtibaa, Khaled A Harras, Karim Habak, Mostafa Ammar, and Ellen W Zegura. Towards mobile opportunistic computing. In 2015 IEEE 8th International Conference on Cloud Computing, pages 11111114. IEEE, 2015. [11] Luiz Andre Barroso and Urs Hölzle. The case for energyproportional computing. Computer, 40(12):33- 37, 2007.
440
2016 IEEE Region 10 Conference (TENCON) - Proceedings ofthe International Conference
