Communication Augmented Scheduling for Cloud Computing with Delay Constraint and Task Dependency. Sowndarya Sundar

Transcription

1 Communication Augmented Scheduling for Cloud Computing with Delay Constraint and Task Dependency by Sowndarya Sundar A thesis submitted in conformity with the requirements for the degree of Master of Applied Science Graduate Department of Electrical and Computer Engineering University of Toronto c Copyright 2016 by Sowndarya Sundar

2 Abstract Communication Augmented Scheduling for Cloud Computing with Delay Constraint and Task Dependency Sowndarya Sundar Master of Applied Science Graduate Department of Electrical and Computer Engineering University of Toronto 2016 Cloud computing can augment the capabilities of resource-poor mobile devices with the help of resourceful servers. It allows reduction of energy consumption and makespan by offloading computationally-intensive applications to the cloud. We consider a system consisting of a remote cloud and a network of heterogeneous local processors. We aim to identify the optimal scheduling decision for a mobile application comprising of dependent tasks, such that the total cost is minimized subject to an application deadline. We propose the Communication Augmented Latest Possible Scheduling (CALPS) algorithm to obtain an approximate solution for this NP-hard problem in polynomial time. We also identify a lower bound to the optimal solution and propose techniques to utilize this lower bound solution to obtain improved versions of the CALPS algorithm. Using simulation results, we compare the proposed solution approaches with each other and with existing work. ii

3 Acknowledgements This work has been funded in part by the Natural Sciences and Engineering Research Council (NSERC) of Canada under grant STPGP Firstly, I would like to express my utmost gratitude to my supervisor, Professor Ben Liang, for his continued support and guidance at every stage of this work. This work would not have been possible without his knowledge, experience and motivation. I am also extremely grateful to my examining committee members: Professor Baochun Li, Professor Alberto Leon Garcia and Professor Andreas Veneris, for allocating time to serve on my defense committee and for their valuable feedback regarding my research work. I would also like to thank my research group mates at the University of Toronto for their feedback, guidance and suggestions. Special thanks are also due to the ECE Graduate Office members: Ms. Darlene Gorzo, Mr. Shawn Mitchell and Ms. Gaja Sanmugaratnam, for their help and support throughout the last couple of years. Finally, I would like to express my gratitude to my family back home for their boundless encouragement and support, and to my friends here at Toronto for providing me with both necessary breaks and constant motivation. iii

4 Contents 1 Introduction Background and Motivation Mobile Cloud Computing Computational Offloading Task scheduling Thesis Contributions Thesis Organization Literature Review Computational Offloading Frameworks Common Computational Offloading Techniques Offloading an Entire Application Offloading Independent Tasks Offloading Dependent Tasks Minimizing Energy Consumption Minimizing Makespan Minimizing Energy Consumption under an Application Deadline System Model and Problem Formulation Device, Cloud and Application Model Local Processors and the Cloud Task Dependency Graph Task Scheduling Decision variables Scheduling Constraints Minimizing the Cost of Application Execution iv

5 4 Proposed Solution Techniques CALPS Algorithm Allocation of Individual Deadlines Scheduling Decision Policy Scaling Factor and Time Complexity Lower Bound to the Optimum Modified CALPS algorithms CALPS-w lb CALPS-F lb Simulation Results CALPS Comparison with the Optimum Comparison with Existing Work Comparison with Greedy Algorithms Scaling Factor Analysis CALPS-w lb and CALPS-F lb Under Practical Delay Under Negligible Delay Summary and Conclusions 42 Bibliography 43 v

6 List of Tables 2.1 Existing Work on Offloading Dependent Tasks Notations Run-time Comparison vi

7 List of Figures 1.1 Mobile Cloud Computing Architecture System Architecture Components Sequential Tasks (a) DAG representing application, (b) DAG with inserted dummy tasks, d1 and d Cost vs. application deadline for small applications Feasibility vs. application deadline for large applications Cost vs. application deadline for large applications Feasibility vs. application deadline for small applications Cost vs. application deadline for small applications Feasibility vs. application deadline for large applications Cost vs. application deadline for large applications Average optimal scaling factor vs. application deadline Application Deadline Vs Cost for d = Application Deadline Vs Cost for d = Application Deadline Vs Feasibility for d = Application Deadline Vs Cost for d = vii

8 List of Symbols M Number of local processors M N Total number of processors (including cloud) Total number of tasks in a DAG representing an application d1, d2 Dummy tasks inserted in a DAG representing an application d Delay per unit data between local processors and cloud L Application deadline t ij p j p c e ik V E P x ijr F i LST i LFT i w d ij c ij SL j Execution time for task i on processor j Processing cost per unit time on processor j Communication cost per unit delay Amount of data to be communicated from task i to task k Set of tasks in the task graph Set of edges in the task graph Set of all processors Binary scheduling decision variable for task i on processor j at position r Finish time of task i Latest Starting Time of task i (set in CALPS) Latest Finish Time of task i (set in CALPS) Scaling factor for a single application in CALPS Accumulated delay when task i is executed on processor j Accumulated cost when task i is executed on processor j Schedule Length of processor j w i Scaling factor of task i (set in CALPS-w lb ) w opt W Optimal scaling factor w value Set of all scaling factor w values used viii

9 Chapter 1 Introduction 1.1 Background and Motivation Mobile Cloud Computing The usage of computationally intensive and resource-demanding applications such as 3D modeling, face recognition and video games on mobile devices has been rapidly increasing in recent times. However, the improvements in the hardware and battery of mobile devices are not sufficient to keep up with the power and time requirements of these new applications. For example, several solutions have been proposed to enhance the CPU performance [4], [5] and to manage the disk and screen in an intelligent manner [6], [7] but, these solutions require changes in the structure of mobile devices, or new hardware that results in an increase of cost and may not be feasible for all mobile devices [1]. As a result, resource poverty is a major obstacle for many applications [8]. The combination of cloud computing, wireless communication infrastructure, ubiquitous computing devices, location-based services, mobile Web, etc., has laid the foundation for a novel computing model called mobile cloud computing [9], which is a promising solution for this problem. The general architecture of the mobile cloud computing scenario is shown in Figure 1.1. Mobile devices are connected to the mobile networks through base stations that establish and control the connections and functional interfaces between the networks and mobile devices. Mobile users requests and information are transmitted to the central processors that are connected to servers providing mobile network services. Here, mobile network operators can provide services to mobile users such as authentication, authorization, and accounting based on the home agent and subscribers data stored in databases. After that, the subscribers requests are delivered to a cloud through the Internet. In the cloud, cloud controllers process the requests to provide mobile users with 1

10 Chapter 1. Introduction 2 Mobile Devices Mobile Network BTS/ Access point Central processors Servers I n t e r n e t VM at Cloudlet/ remote Cloud Cloud Controller Application Servers Data Center Internet Service Providers Application Service Providers Figure 1.1: Mobile Cloud Computing Architecture the corresponding cloud services [1]. The cloud abstracts the complexities of provisioning computation and storage infrastructure [10], and gives the mobile user access to nearly unlimited computing power. This helps combat the resource poverty by augmenting the capabilities of the mobile devices through a technique called computational offloading. As a result, mobile cloud computing has been proven to be advantageous for several applications such as mobile commerce, mobile learning, mobile healthcare, gaming [1], image and language processing [11], sharing GPS/internet data [12], and crowd computing [13]. However, there are several challenges that are associated with the usage of mobile cloud computing, such as network connectivity, data communication, privacy, pricing, etc Computational Offloading Computational offloading refers to the migration of the computationally intensive parts (or tasks) of an application from the mobile device to more powerful servers at the remote cloud. This means that the execution of these resource-hungry parts of the application takes place in the cloud and the results of the execution can be communicated to the mobile device for further execution or to output results. This can prove to be extremely beneficial for the application users for the following reasons: Augments capabilities of the mobile device As the servers in the cloud are much more powerful in terms of speed and capability

11 Chapter 1. Introduction 3 than the local processors in the mobile device, computational offloading enables the mobile device to run even computationally-intensive applications that the local processors alone cannot handle. In other words, computational offloading gives the mobile user access to nearly unlimited computing power thereby rendering the mobile device more resourceful. Decreases energy consumption Offloading parts of the application implies that the mobile device has lesser work in terms of execution, and this consequently results in reduction of energy consumption at the mobile device. As a result, this helps improve the mobile device s battery lifetime. Improves response time The execution of some parts of the application at the faster servers at the cloud can result in reduction of the time taken to execute the overall application, also known as the makespan of the application. As a result, this improves the response time of the application. Existing research work has resulted in several computational offloading systems such as energy-aware migration decisions at run-time [11], multiple virtual machine images [14], and trusted cloudlets [8] Task scheduling Each mobile application can be modelled as a number of tasks, and each task can be executed either locally at the mobile device or remotely at the cloud. This binary decision on each task should be taken such that the offloading for the entire application is optimal in terms of the objective, such as minimizing the overall energy consumption or the makespan. This partitioning of the application into tasks results in greater flexibility on selectively offloading tasks in finer granularity [15], [16] and proves to give better results than offloading the entire application [17]. Furthermore, by performing task scheduling to determine where to execute each task, we can also identify the best possible offloading decision, one that minimizes cost/energy for the entire application, subject to latency constraints on the execution of the application in order to provide a Quality of Service guarantee to the application users [11], [15], [18]. The tasks that constitute an application can be considered to be independent or dependent in nature based on precedence constraints and possible data communication

12 Chapter 1. Introduction 4 between them. Dependent tasks are often modelled using a task graph with nodes of the graph representing the tasks and the edges in the graph representing the dependencies between the tasks. There are several different techniques that can be used to identify the best task scheduling decision, and these are investigated in Sections 2.2 and 2.3. The main motivation of this study lies in identifying this best task scheduling decision for computational offloading in mobile cloud computing. 1.2 Thesis Contributions The main goal of this work is identifying the best computational offloading decision for a mobile application comprising of dependent tasks, such that the total cost is minimized subject to an application deadline. The step-by-step objectives towards achieving this goal are as follows. 1. Define the system model for computational offloading such that it is representative of the practical setting and incorporates all scheduling constraints. 2. Formulate the computational offloading/task scheduling decision as the solution to an optimization problem. 3. Identify and propose multiple solution approaches to solve this problem and obtain the scheduling decision. 4. Using simulation results, study the performance of these approaches under different parameter settings. 5. Compare and contrast the solutions obtained with each other and with those obtained from existing work. 1.3 Thesis Organization This thesis is organized in the following manner. Chapter 1 introduces the background and motivation behind our work, and briefly introduces the concepts of mobile cloud computing, computational offloading and task scheduling. The objectives and contributions of the work are also presented. Chapter 2 deals with the literature review wherein the existing computational offloading techniques are analyzed. The scheduling techniques for dependent tasks are investigated in detail and compared.

13 Chapter 1. Introduction 5 Chapter 3 defines a novel and practical system model for computational offloading and the task scheduling constraints under this model are described. The task scheduling optimization problem is then formulated. Chapter 4 explains the proposed solution techniques. The CALPS algorithm, a lower bound, and modified versions of the algorithm are introduced and analyzed. Chapter 5 depicts the results and the performance of the proposed techniques. These solutions are compared with each other and with existing work. Chapter 6 summarizes the work and provides conclusions. Additionally, future work and possible extensions of this work are proposed.

14 Chapter 2 Literature Review The literature review for this work consists of studying the computational offloading decision-making techniques proposed in existing work and analyzing the positives and negatives of each technique. Section 2.1 briefly introduces the existing frameworks in order to obtain a basic understanding of the overall structure of the computational offloading system. Section 2.2 presents the existing computational offloading techniques or policies that concern the offloading of an entire application or independent tasks. Since our work deals with the offloading of dependent tasks, Section 2.3 analyzes the existing work in this area extensively. The different techniques used to find the task scheduling decision for different objectives under different constraints and system models are studied and compared. 2.1 Computational Offloading Frameworks Before we analyze the various computational offloading and task scheduling techniques, it is important to acknowledge the infrastructure required in order to facilitate this process. We require a partitioning scheme that focuses on partitioning the application into different parts or tasks and that marks the parts as remote-able or not remote-able. This partitioning can be either done by the programmers [19], [20] or by a profiler that partitions applications automatically [11], [21] [22]. Some works also assume full VM migration wherein the individual applications, with all their program state and code, is sent to the remote infrastructure, namely the cloud, thereby eliminating the need for partitioning [8], [23]. While this reduces the need for a programmer or a profiler, it does not have the flexibility that is rendered by fine-grained code offload. We also require a decision engine or scheduler that decides where to schedule each part. The existing decision-making and task scheduling schemes are analyzed in the next 6

15 Chapter 2. Literature Review 7 Mobile Device Mobile Application Profiler Cost/Makespan Estimation Model Decision Engine VM at Cloudlet/Remote Cloud Communication Manager Profiler Task Manager Communication Manager Figure 2.1: System Architecture Components chapter. Furthermore, in addition to the mobile device infrastructure, the cloud infrastructure needs to be considered. The location of the clouds and their availability impacts the communication delay and energy consumed to communicate data from the mobile device to the cloud among several other factors. Figure 2.1 describes the basic system architecture, consisting of several components including program profiler, decision engine, cost estimation model, task manager, etc. The following are a few existing prominent computational offloading frameworks and their salient features. Tactics-based system Partitioning is application-specific. In [22], it is shown that automated dynamic re-partitioning of mobile applications can be reconciled with the need to exploit application-specific knowledge. This useful knowledge is captured in a compact declarative form called tactics, and sound partitioning and placement of application using tactics is performed. Weblets In [24], elastic applications, i.e., applications that consist of several parts called weblets are considered. Partitioning into weblets is to be performed by application developers such that these weblets have minimal dependencies between them and a weblet s functionality is not affected by the location or environment where it is running. Each weblet is then scheduled on the mobile device or the remote cloud using a decision-making scheme.

16 Chapter 2. Literature Review 8 CloneCloud CloneCloud is a system that looks to boost unmodified mobile applications by offloading the right portion of their execution onto device clones operating at the cloud [23], [21]. At runtime, the application partitioning is effected by migrating a thread from the mobile device at a chosen point to the clone in the cloud, executing there for the remainder of the partition, and re-integrating the migrated thread back to the mobile device [21]. Cloudlets Cloudlets are resourceful servers that are available for use by nearby mobile devices. They are beneficial in situations where offloading to the remote cloud incurs a large amount of communication delay or takes up a large amount of energy/cost. In this way, mobile users may meet the demand for real-time interactive response by lowlatency, one-hop, high-bandwidth wireless access to the cloudlet. Cloudlets and their impact on offloading mobile applications is being widely studied [8], [25], [26]. Our work does not deal with partitioning applications or designing some suitable infrastructure. Instead, it focuses on decision-making or task-scheduling schemes to be used after the application has been partitioned into tasks using any one of the aforementioned methods. As a result, in the following sections, we investigate several techniques used to take this computational offloading decision. 2.2 Common Computational Offloading Techniques There has been a large volume of work in this area in recent years. The works are extremely varied in the assumptions they make and the system models they consider. In this section, we study this existing work in computational offloading and the prominent techniques used to find the optimal scheduling decision Offloading an Entire Application The computational offloading technique that was initially studied considered just two possible outcomes to the scheduling decision, namely, either offloading the entire application to the cloud or executing the entire application locally on the mobile device [8], [23], [17]. In [17], this decision is made with an objective to conserve energy for the mobile device. The application profile is modelled using two parameters; the input data size L and an application completion deadline T. The energy-optimal execution policy is

17 Chapter 2. Literature Review 9 obtained by solving two constrained optimization problems, i.e., optimizing the clock frequency to complete CPU cycles for mobile execution and the data transmission rate for cloud execution. Consequently, the optimal energy given the deadline is obtained separately for mobile execution and cloud execution, namely Em and Ec respectively, and the application is scheduled in the location where this energy is minimum. These optimal energy levels are obtained as E m = min ψ Ψ E{E m(l,t,ψ)} (2.1) where ψ is any clock-frequency vector that meets the delay deadline, Ψ is the set of all feasible clock-frequency vectors and E m (L,T,ψ) is the energy consumed by the mobile device; and E c = min φ Φ E{E c(l,t,φ)} (2.2) where φ denotes a data transmission schedule that meets the delay deadline, Φ is the set of all feasible data schedules, and E c (L,T,φ) denotes the transmission energy. While the numerical results indicate significant energy savings, and this offloading technique eliminates the need for partitioning, offloading in finer granularity is more flexible and beneficial than standalone mobile or standalone cloud execution [15], [16] Offloading Independent Tasks Each mobile application can be partitioned into a number of tasks, and each task can be executed either locally at the mobile device or remotely at the cloud. This binary decision on each task should be taken such that the offloading for the entire application is optimal in terms of the objective such as minimizing the overall energy consumption or the makespan. This partitioning of the application into tasks results in greater flexibility on selectively offloading tasks and proves to give better results than offloading the entire application [17]. Some existing works assume that the mobile application is partitioned into independent tasks. This simplifies the problem formulation and decision-making due to the absence of precedence constraints between the tasks. In [2], a context-aware decisionmaking algorithm is formulated to schedule independent tasks, taking into account the wireless medium, cloud resources, etc. Here, the objective is to schedule the tasks such that the overall execution time and energy among all cloud resources is minimized. Similarly, [27] aims to optimize the offloading decision of the user to minimize the overall cost of energy, computation, and delay for an application consisting of multiple independent

18 Chapter 2. Literature Review 10 tasks using semidefinite relaxation and randomization mapping approaches. However, in reality, the tasks that constitute an application may be dependent in nature due to some data communication required, and consequently, there exists some precedence constraints between them. As a result, we focus on those works in literature that consider dependent tasks in the next section. 2.3 Offloading Dependent Tasks Each of the following techniques have been employed to identify an offloading decision on an application consisting of dependent tasks satisfying some objective. In Table 2.1, we summarize these techniques, and their advantages and disadvantages Minimizing Energy Consumption Computational offloading decisions can be taken with the sole objective of minimizing the energy consumption or overall cost due to application execution. Cost and energy can be considered to be analogous in nature and hence, we study the works that look to minimize either of these objectives. Graph Partitioning In [3], the problem of minimizing the sum of the cost (consisting of computation cost, data communication cost, task scheduling cost, and data registration cost) is addressed using graph partitioning. The dependencies between the tasks are modelled using a general task control flow graph. The authors propose an algorithm to solve the parametric min-cut problem. This solution divides the graph into two different sets such that the overall cost is minimized, wherein one set contains the tasks that are to be executed on the client or mobile device and the other set consists of the tasks that are to be offloaded to the cloud. This work formulates the problem with the assumption that tasks on the cloud and tasks on the mobile device cannot be executed simultaneously. Additionally, the parametric algorithm that is proposed in this paper requires the use of a min-cut algorithm, but the best-known min-cut algorithms run in O(n 3 ) time, where n is the number of tasks in the graph.

19 Chapter 2. Literature Review 11 Pruned Branch-and-Bound Algorithm Similar to the work in [3], [28] constructs a cost graph for a given application and then uses a task mapping algorithm to statically divide the application into server tasks and client tasks such that the energy consumed by the application is minimized. The task mapping algorithm that they propose is a pruned branch-and-bound algorithm. The branch-and-bound algorithm, on its own, will produce an optimal solution but has exponential-time complexity in the size of the cost graph. Consequently, the authors propose a pruning heuristic to shorten the solution search space. The branchand-bound algorithm is then applied to this reduced search space, which decreases the time complexity of the task mapping algorithm. While the pruning heuristic helps to reduce the time complexity, it only provides an approximate solution to the problem of minimizing energy consumption. Alternatively, the branch-and-bound algorithm provides an optimal solution but has exponential-time complexity. Furthermore, [28] also makes the assumption that tasks on the cloud and tasks on the mobile device are not executed simultaneously. Similarly, they also assume that computation and communication cannot take place simultaneously. These assumptions have been justified in [28] by stating that they see no realistic gain by parallel execution as the objective is to solely minimize energy consumption. However, exploiting the parallelism between the mobile device and the cloud can largely help improve the makespan of the application [29] Minimizing Makespan We now study the techniques that can be employed while offloading dependent tasks to reduce makespan of the application and consequently improve response time. One-time Offload Property: Linear Topology Optimal offloading techniques to minimize makespan can be found for an application consisting of sequential tasks, i.e., considering only task graphs with linear topology, as shown in Figure 2.2. In [30], the one-time offload property has been proven for sequential tasks. This property states that the optimal set of tasks to be offloaded in a sequential task graph while minimizing makespan will always be a sequence of consecutive tasks in the task graph. In [29], an algorithm is proposed to find the entry-task and exit-task of the optimal one-time offload such that makespan or completion time is minimized.

20 Chapter 2. Literature Review N Figure 2.2: Sequential Tasks Load Balancing For generic task graphs, a load balancing heuristic is suggested in [29] to identify the offloading decision. This is based on the idea that in order to minimize makespan, we need to exploit the parallelism between the mobile device and the cloud by load-balancing the tasks on the mobile device and the cloud. This load balance is achieved in [29] using the following minimization objective: min (2r 1)(T M T C ) T net (2.3) where T M is the total time taken to execute tasks at the mobile device, T C is the total time taken to execute tasks at the cloud, T net is the total transmission time, and r is a variable that is zero if the root task is on the cloud and one otherwise. Numerically, this load balancing heuristic is shown to give better performance in comparison with the greedy offloading algorithm in Odessa [31]. Greedy Heuristics In [32], applications consisting of dependent modules (or tasks), multiple finite-capacity servers at the cloud, and multi-user scenarios are considered. The finite-capacity of the servers is modelled by assuming that each cloud server can only process one module at one time but this finite-capacity assumption is not extended to the mobile device. A Mixed Integer Linear Programming (MILP) problem is formulated with the objective of minimizing makespan or total application delay. Furthermore, two greedy heuristics are proposed to obtain solutions. Genetic Algorithm The problem of task scheduling onto unrelated parallel machines is considered in [33], with an application to cloud computing. In this work, there exist precedence constraints between tasks of the application, but no communication delay is considered between the

21 Chapter 2. Literature Review 13 processors and no data communication is considered between tasks. The problem of minimizing the completion time is formulated, and genetic algorithms are proposed to obtain a solution Minimizing Energy Consumption under an Application Deadline Purely minimizing the energy consumption without regard to the makespan could result in large application delays, particularly in practical systems wherein faster processors consume more energy and vice-versa. Similarly, purely minimizing the makespan could result in large amounts of energy being consumed. As a result, the objective of minimizing energy under an application deadline has been considered in order to achieve a tradeoff between these two important quantities and consequently provide better Quality-of- Service (QoS) guarantee to the user. Integer Linear Programming The problem of maximizing energy savings at the mobile device due to computational offloading, subject to an application deadline, is formulated as an integer linear program in [11]. A general task graph is used for modeling an application, and a default latency deadline is considered in addition to communication delay between the mobile device and remote cloud. While integer linear programming provides an optimal solution, it is NP-hard in general and hence, there is no polynomial run-time guarantee. Furthermore, it is assumed that the cloud tasks and client tasks do not run simultaneously, thereby eliminating any parallelism between the mobile device and the cloud that could contribute to lower makespan. Additionally, mobile devices are assumed to be capable of simultaneously processing any number of tasks without any loss in speed or efficiency. Execution of tasks and data communication between the cloud and the mobile device can not happen simultaneously in their proposed system model. Dynamic Programming Another commonly used technique to identify an optimal solution in polynomial time is dynamic programming. In order to identify the task scheduling decision that minimizes the energy consumption for dependent tasks under a deterministic application deadline or a probabilistic application deadline, [18] proposes a dynamic programming approach. The approach uses the following technique:

22 Chapter 2. Literature Review 14 The time domain is quantized. For each task, starting from the root and moving towards the leaves, the minimum accumulated energy consumption subject to each point in the quantized time domain is found. Using this two-dimensional matrix of minimum accumulated energy consumption at (task, time point), we can now backtrack from (last task, application deadline) to find the task scheduling decision. However, the optimality of the task scheduling decision and the run-time of the proposed algorithm depends on quantization of the time domain and choice of step-size. Furthermore, the algorithm assumes that mobile devices are capable of simultaneously processing any number of tasks without any loss in speed or efficiency. This assumption simplifies the problem and consequently allows dynamic programming to be used to provide a solution. LARAC algorithm In [15], the classical LARAC (Lagrangian Relaxation Based Aggregated Cost) algorithm is adopted to obtain an approximate solution for the problem of minimizing energy consumption at the mobile device subject to an application deadline. However, instead of using a general task graph to model applications, the specific case of sequential tasks is considered and a linear topology graph, such as that shown in Figure 2.2, is used. The proposed problem can be converted to a constrained shortest path problem. Furthermore, it is shown through simulations that a one-climb offloading policy (described in Section 2.3.2) is optimal under the Markovian stochastic channel by using the Markov decision process to identify the task scheduling policy. The assumptions regarding the finite-capacity of the mobile device and the cloud, and the inability to handle execution and communication simultaneously that were considered by [11] and [18] does not affect this model since only linear-topology applications are considered. This is because these applications require that at any point in time only a single task is processed either at the cloud or at the mobile device, and the data is communicated following the execution of the parent task and before the execution of the child task.

23 Chapter 2. Literature Review 15 Ref. Table 2.1: Existing Work on Offloading Dependent Tasks Min. Technique Solution Assumptions Objective [10] Total cost Graph Partitioning Optimal in O(n 3 ) time Cloud & client tasks do not execute simultaneously [28] Energy consumption Pruned Branch & Bound Approximate; high complexity Cloud & client tasks do not execute simultaneously [29] Makespan One-time offload Optimal [32] Makespan Greedy Heuristics Approximate Sequential tasks Infinite capacity mobile device [33] Makespan Genetic Algorithm Approximate; high complexity No communication Cloud & client [11] Energy consumption under deadline Integer Linear Programming Optimal; exponential time complexity tasks do not execute simultaneously; Infinite capacity mobile device [18] Energy consumption under deadline Dynamic Programming Optimal; step-size dependent time complexity Infinite capacity mobile device [15] Energy consumption under deadline LARAC algorithm Approximate Sequential tasks

24 Chapter 3 System Model and Problem Formulation We see from Table 2.1 that several assumptions have been made in existing work that render the system models impractical, limiting their application to real-life scenarios. In this thesis, our system model incorporates the features in existing works such as an application consisting of dependent tasks, a remote cloud, communication delay between the mobile device and remote cloud, an application deadline, etc. Additionally, our system model accommodates the following features: Finite-capacity of the mobile device Practical mobile devices have finite processing speed and power. But this is often ignored by assuming infinite capacity for the mobile device in terms of the number of tasks it can process at any point in time (without reduction in processing speed) in order to make the problem formulation simpler. In our system model, the mobile device can only process a finite number of tasks at any point in time. Simultaneous execution of cloud tasks and device tasks The tasks on the mobile device and the cloud are executed simultaneously in order to enable parallelism and thereby reduce the makespan or the completion time of the application. This will enable us to take better task scheduling decisions. Simultaneous execution and communication It is assumed by multiple works that task execution and data communication do not happen simultaneously, and the makespan is simply found by summing up the total execution time and the total communication time. However, in a practical 16

25 Chapter 3. System Model and Problem Formulation 17 model, the remote cloud might complete the execution of a task and send the output data to the mobile device while the mobile device is still executing another task. Furthermore, allowing task execution and data communication to happen simultaneously reduces the makespan of the application. In the following chapter, we study our system model and problem formulation in detail. Section 3.1 describes the modeling of the local device and the remote cloud, and the mobile application. Section 3.2 introduces the task scheduling decision variables and explains each of the constraints that influence the task scheduling decision (including the application deadline). Section presents the optimization problem formulation for minimizing the overall cost. The terminology cost is used throughout our work due to the generality of our formulation which allows the cost to be analogous to energy consumption, pricing etc. 3.1 Device, Cloud and Application Model Local Processors and the Cloud We consider a system with M local processors and one remote cloud. We denote the set of processors, including the cloud, by P. The total number of processors is M = M +1. (3.1) We assume that the communication time between local processors is negligible. In many practical scenarios, these local processors belong to the same mobile device. However, our study is more generally applicable, possibly to scenarios where nearby devices pool their processors in a shared cloudlet [8]. Each local processor is capable of executing only one task at a time, while the remote cloud is viewed as a processor capable of executing an infinite number of tasks simultaneously. All the M processors are heterogeneous in our model in terms of the processing speed and processing cost per unit time Task Dependency Graph Consider a single application that is partitioned into tasks and must be completed before a deadline L. The dependencies between the tasks is modeled as a Directed Acyclic Graph (DAG) G = V,E where V is the set of tasks and E is the set of edges. The edge (i,k) on the graph specifies that there is some required data transfer, e ik, from task i to

26 Chapter 3. System Model and Problem Formulation 18 d d2 (a) (b) Figure 3.1: (a) DAG representing application, (b) DAG with inserted dummy tasks, d1 and d2 task k and hence, i cannot start before k finishes. Furthermore, if they are scheduled at different locations (one locally and the other at the cloud), the communication delay is e ik d and the communication cost is p c e ik d, where d is the delay per unit data and p c is the communication cost per unit time. When task i is executed on processor j, the execution time is t ij, and the execution cost is p j t ij, where p j is the processing price per unit time on processor j. We assume that an application is initiated at a local processor and must end at a local processor. To model this requirement, for a given DAG representing an application (which is illustrated in part (a) of Figure 3.1), we insert two dummy tasks, i.e., tasks having zero execution time and zero communication cost. One dummy task is inserted at the start to trigger the application at the local device and another task is inserted at the very end to receive all the results back at the local device. This allows for all the tasks of the application to be scheduled either at the mobile device or at the cloud depending on where it achieves the optimal objective. The modified DAG is depicted in part (b) of Figure 3.1. This insertion is without loss of generality since it preserves the application. Hence, the total number of tasks, including the dummy tasks, can be considered to be N = V +2. (3.2)

27 Chapter 3. System Model and Problem Formulation 19 Notation t ij p j p c e ik d L V E Table 3.1: Notations Description execution time for task i on processor j processing cost per unit time on processor j communication cost per unit delay amount of data to be communicated from task i to task k delay per unit data between local processors and cloud application deadline set of tasks in the task graph set of edges in the task graph 3.2 Task Scheduling Decision variables We now introduce the decision variables required to identify, for each task, the processor to which it must be allocated. As every local processor can process only a single task at a time, the task scheduling decision must also contain the order of the tasks allocated to the processor, which should satisfy the precedence constraints and the application deadline. We define the task scheduling decision variables as follows: 1 if task i is on processor j in position r, x ijr := 0 if otherwise, (3.3) i = 1,...N,j = 1,...M and r = 1,...N. The positions dictate the order of the tasks and can be viewed as a queue of tasks assigned to a processor, wherein a task in position r cannot be processed unless the tasks before position r, i.e., tasks in positions (r 1), (r 2), etc. have been processed. It is to be noted that if the M local processors are on one mobile device, the device can only process M tasks at any point in time. This allows us to model the finite-capacity local device in a manner representative of the practical scenario wherein we have multi-core

28 Chapter 3. System Model and Problem Formulation 20 mobile devices. Here, each core represents a single local processor. Furthermore, our assumption that each local processor can only execute one task at a time is without loss of generality. This is because our performance metrics, total cost and makespan of the application, do not improve if time-sharing is incorporated Scheduling Constraints These task scheduling decision variables are subject to several constraints. We shall now investigate each of these. Firstly, each task is to be scheduled to exactly one of the existing positions on the processors. Hence, M N x ijr = 1, i = 1,...,N. (3.4) j=1 r=1 Furthermore, each position on each processor can be assigned to atmost one task, which is given by: N i=1 x ijr 1, r = 1,...,N, j = 1,...,M. (3.5) The positions in each processor are filled by the tasks sequentially, i.e., until one position on a processor is occupied, tasks cannot be assigned to subsequent positions. This is imposed by the following constraint: N N x ijr x ij(r 1) 0, i=1 i=1 r = 2,...,N, j = 1,...,M. (3.6) The two dummy tasks inserted (shown in Figure 3.1 (b)) are required to be scheduled on a local processor, so we have N x 11r = 1, N r=1 r=1 x N 1r = 1. (3.7) Furthermore, our task scheduling decision is required to meet the application deadline, which imposes constraints on the finishing times of the tasks. If i = 1,...N, F i is the finish time of task i, then F N L (3.8)

29 Chapter 3. System Model and Problem Formulation 21 ensures that the last dummy task, and consequently the overall application, is completed by the deadline. In addition, F 1 = 0 (3.9) sets the finish time of the first dummy task to zero as it has zero execution time. The relationship between the finish times of the tasks and the decision variables is given by F i F k +C(2 x ijr x kj(r 1) ) t ij, i,k = 1,...N, r = 2,...,N, j = 1,...,M (3.10) where we assign C to be a large positive number. This ensures that the finish time of a task in sequence on a local processor is at least equal to the sum of the finish time of the preceding task and the processing time of the present task. Note that 2 x ijr x kj(r 1) is zero if and only if tasks k and i are placed consecutively on processor j. The tasks of the application are dependent in nature. This implies that the finish time of a task must be greater than its predecessor by the amount of its execution time and communication time from its predecessor. Thus, if task k is a predecessor of task i, we have N M N N M F i F k t ij x ijr +e ki d (x ijr x km t +x im rx kjt ), r=1 j=1 t=1 r=1 j=1 i = 1,...N, (k,i) E. (3.11) The first term of (3.11) is the execution time of task i, and the second term is the communication time from task k to task i, which occurs when task i is executed on one of the M local processors and k is executed on the cloud or vice-versa Minimizing the Cost of Application Execution The total cost of execution of the application is the sum of the total execution cost and the total communication cost. Our goal is to identify the schedule, or the decision variables x ijr, that minimizes this total cost, subject to the deterministic application deadline, L. This can be formulated as an optimization problem, taking into account the con-

30 Chapter 3. System Model and Problem Formulation 22 straints investigated in Section 3.2.2, as follows: minimize {x ijr } [ N N N N ] N M p j t ij x ijr +p c d e ki (x ijr x km t +x im rx kjt ), N M r=1 j=1 i=1 subject to (3.4) (3.11), k=1 i=1 t=1 r=1 j=1 (3.12) x ijr {0,1}, i = 1,...N,r = 1,...,N,j = 1,...,M. (3.13) The first term of equation (3.12) is the total execution cost wherein execution cost of each task is defined as product of processing cost per unit time on the processor and execution time of the task. The second term of (3.12) is the total communication cost which is zero when subsequent tasks are in the same location (both at the local device or both at the cloud) and p c de ki otherwise. Constraint (3.13) forces the decision variables to take on binary values.

31 Chapter 4 Proposed Solution Techniques The problem formulation in Section is NP-hard in nature. This can be shown by considering a special case of the proposed problem, with independent tasks and no communication. This is equivalent to the Generalized Assignment Problem (GAP), as shown in the formulation in (4.1). The GAP problem has been proven to be NP-hard thereby establishing that our proposed problem with dependent tasks and communication is atleast as hard. minimize {x ij } N M i=1 p j t ij x ij j=1 N subject to t ij x ij L j = 1,...,M ; M j=1 i=1 x ij = 1 i = 1,...,N ; x ij {0,1} i = 1,...,M, j = 1,...,N ; (4.1) Hence, there is no guarantee of obtaining the optimal solution in polynomial time. As reasonable alternatives, we propose the following: CALPS algorithm, an efficient heuristic. (Section 4.1) Lower Bound to the Optimum, for benchmarking. (Section 4.2) Modified versions of the CALPS algorithm, for improved run-time and reliability. (Section 4.3) 23

32 Chapter 4. Proposed Solution Techniques CALPS Algorithm The Communication Augmented Latest Possible Scheduling or CALPS algorithm consists of the following major steps: Step 1: Allocate deadlines to the individual tasks derived from the overall application deadline. Step 2: Pick an unscheduled task i whose predecessors have already been scheduled. Assign it to the processor j wherein it completes its execution before its individual deadline and produces minimum additional cost. Step 3: Repeat Step 2 untill all tasks are scheduled or infeasibility is revealed Allocation of Individual Deadlines Firstly, we wish to break down the overall deterministic application deadline L into deadlines for each individual task. Step 1 of this algorithm sets, for each task i, the values LST i and LFT i, which refer to the latest starting time and the latest finish time of task i respectively. Specifically, we expect LST i for a task i with successor k to be LST k min LST i t ij if no communication between i and k j P (4.2) LST k min t ij de ik if communication between i and k j P However, prior to taking the scheduling decision, we are not aware of whether there will be a communication delay between tasks i and k as we do not know the future locations of i and k. Assuming no communication between the tasks could cause the deadlines for the tasks to be too loose and assuming communication could cause the deadlines to be too tight. Either extreme scenario does not give good results when applied to our scheduling policy. Hence, we use the following technique to compute LST i and LFT i : L if i = N LST i := min (LST k min t ij wde ik ) if otherwise, k:(i,k) E j P L if i = N LFT i := LST i +min if otherwise, j P t ij (4.3) (4.4) where w is a parameter or scaling factor used to tune the importance of communication delay for individual tasks. The completion time deadline for task i is now set to LFT i.