A Novel Graph-based Computation Offloading Strategy for Workflow Applications in Mobile Edge Computing
IIEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID 1
A Novel Graph-based Computation Offloading Strategy for Workflow Applications in Mobile Edge Computing
Xuejun Li,
Member, IEEE,
Tianxiang Chen, Dong Yuan,
Member, IEEE,
Jia Xu,
Student Member, IEEE, and Xiao Liu,
Senior
Member, IEEE
Abstract —With the fast development of mobile edge computing (MEC), there is an increasing demand for running complex applications on the edge. These complex applications can be represented as workflows where task dependencies are explicitly specified. To achieve better Quality of Service (QoS), for instance, faster response time and lower energy consumption, computation offloading is widely used in the MEC environment. However, many existing computation offloading strategies only focus on independent computation tasks but overlook the task dependencies. Meanwhile, most of these strategies are based on search algorithms such as particle swarm optimization (PSO), genetic algorithm (GA) which are often time-consuming and hence not suitable for many delay-sensitive complex applications in MEC. Therefore, a highly efficient graph-based strategy was proposed in our recent work but it can only deal with simple workflow applications with linear (namely sequential) structure. For solving these problems, a novel graph-based strategy is proposed for workflow applications in MEC. Specifically, this strategy can deal with complex workflow applications with nonlinear (viz. parallel, selective and iterative) structures. Meanwhile, the offloading decision plan with the lowest energy consumption of the end-device under the deadline constraint can be found by using the graph-based partition technique. We have comprehensively evaluated our strategy using both a real-world case study on a MEC based UAV (Unmanned Aerial Vehicle) delivery system and extensive simulation experiments on the FogWorkflowSim platform for MEC based workflow applications. The evaluation results successfully demonstrate the effectiveness of our proposed strategy and its overall better performance than other representative strategies.
Index Terms —Mobile Edge Computing, Workflow Management, Energy Consumption, Computation Offloading, Directed Acyclic Graph —————————— ——————————
1 I
NTRODUCTION
ITH the continuous improvement of the computing capacity of various smart end-devices, an increasing number of intelligent applications are deployed on mo-bile end-devices such as smart traffic, smart healthcare, smart logistics and so on. Meanwhile, massive computa-tion requests submitted by the end-devices can be han-dled by cloud datacentres with unlimited computing re-sources. However, massive data transmission over public networks with limited bandwidth will cause significant delays, which is unacceptable for many delay-sensitive applications. Nowadays, mobile edge computing (MEC) has been widely used to provision computing resources from the network edge to the end-device in order to re-duce response delay [1]. Computation tasks on the end-devices can be offloaded to the edge servers for execution through low-cost and high-bandwidth transmission such as the 5G and WIFI networks [2]. Computation offloading plays a key role in effectively improving the QoS of MEC- based applications by reducing the response delay and the energy consumption of end-devices [3], [4]. Given the success of MEC, there is an increasing de-mand for running complex applications on the edge. For example, in the UAV (Unmanned Aerial Vehicle) based smart delivery system, there are many complex applica-tions such as dynamic route planning, obstacle detection and face recognition [5]. These applications are important parts of the whole delivery process. However, like most smart end-devices, UAVs are limited by their computing power and battery life so that they are unable to execute computation-intensive tasks as mentioned above. Fortu-nately, the UAV’s energy consumption and task response time can be effectively reduced by the computation of-floading technology in the MEC environment [6]. Mean-while, as will be shown in the motivating example in the next section, most complex applications in the real-world can be rep-resented by workflows where task dependen-cies are explicitly specified [7]. However, currently many studies only focus on independent tasks without consid-ering task dependencies. A few of them considered sim-ple linear task dependencies where tasks are executed in a sequential manner [8], [9], [10]. Generally speaking, all real-world applications can be represented by a mix of linear (namely sequential) and nonlinear (viz. parallel, selective, and iterative) structures [11]. Therefore, com-putation offloading for complex applications should be xxxx-xxxx/0x/$xx.00 © 200x IEEE Published by the IEEE Computer Society ———————————————— X. Li, T. Chen and J. Xu are with the School of Computer Science and Technology, Anhui University, Hefei, Anhui, China. E-mail: [email protected]; [email protected]; [email protected]. D. Yuan is with the School of Electrical and Information Engineering, University of Sydney, Sydney, NSW 2006, Australia. E-mail: [email protected]. X. Liu is with the School of Information Technology, Deakin University,
Geelong, Australia. E-mail: [email protected].
Manuscript received X. 2020; revised X. 2020; accepted X. 2020. Date of publication X. 2020; date of current version X. 2020. (Corresponding author: Xiao Liu.) W IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID able to deal with both linear and nonlinear structures. Meanwhile, given the complex nature of the computa-tion offloading problem, the greedy type of strategies have been widely used to obtain a feasible solution in a short time [12], but they cannot produce optimal offload-ing decisions. Therefore, in order to improve the quality of the decisions, many studies employed search algo-rithms such as particle swarm optimization (PSO) and genetic algorithm (GA) to search for the optimal offload-ing decision by iterative process, which could produce significant time overhead [13], [14], [15], [16]. In [17], Hu et al., proposed a learning-driven algorithm to achieve efficient offloading decision plans, which need lots of pri-or data training to get an effective model. Therefore, at present, most computation offload-ing strategies are ei-ther simple but not good enough, or they are too time-consuming to be suitable for delay-sensitive complex ap-plications [18],[19].
To address the above issues, a novel computation of-floading strategy using graph partition technology is proposed in this paper for workflow applications in MEC. To distinguish with our previous preliminary work which can only deal with linear work-flow structures [20], we name the previous strategy Graph4Edge-Linear, name the new strategy proposed in this paper Graph4Edge-Nonlinear. Our proposed strategy considers the influence of the complex task dependencies on the computation of-floading decisions, and the end device’s energy consump-tion is optimized effectively under the given deadline con-straints. Please note that the energy consumptions of edge servers are not considered in this paper. This is because edge servers are usually connected to the power grid, and hence their energy consumptions are not regarded as limit-ing factors in a MEC environment. Specifically, the novel contributions of this paper are summarized as follows: 1)
A novel nonlinear workflow model for complex MEC-based applications is proposed. The model is based on WDG (Workflow Dependency Graph) which considers both complex task dependencies and the objective of reducing the end-device’s ener-gy consumption. 2)
We propose a novel graph-based computation of-floading strategy named Graph4Edge-Nonlinear based on the WDG which can find the best compu-tation offloading decision with the minimum end-device’ energy consumption under the given deadline. Its performance is significantly better than popular search-algorithm based strategies. 3)
Both a case study on a real-world UAV delivery system [21] and extensive simulation experiments on the FogWorkflowSim platform for MEC based workflow applications [22] are presented. The ex-perimental results demonstrate the effectiveness of our proposed strategy and its overall better per-formance than other representative strategies. The rest of this paper is structured as follows: Section 2 introduces a motivating example on a MEC-based UAV delivery system. Section 3 presents some preliminaries for this study. Section 4 proposes our novel graph-based com- putation offloading strategy for workflow applications with nonlinear structures. Section 5 presents the evaluation results. Section 6 reviews the related works for computa-tions offloading. Finally, Section 7 makes the conclusions and points out some future work.
2 M
OTIVATION E XAMPLE A ND P ROBLEM A NALYSIS
An example of the MEC-based UAV last-mile delivery scenario is presented to describe the problem of computa-tion offloading in the MEC environment in this section. In the MEC-based UAV last-mile delivery system, there are various delay-sensitive applications such as dynamic flight route planning and autonomous obstacle avoidance for UAVs, pose and face recognition for receivers [23], [24]. These applications usually consist of object detection, pat-tern recognition and video stream processing, which are computation intensive tasks. In fact, because of the UAV’s limited battery life and computing power, these computa-tion intensive tasks are not suitable for executed locally under the fast response and energy efficiency requirements. Therefore, computation offloading to the edge server is often required.
Final Parcel Delivery WorkflowEdge Servers
LANWLAN
Computation Offloading
Frame Filtering Target Detection
Image Segmentation
Pre-processingPose RecognitionPose RecognitionFace RecognitionFace RecognitionConfirm Receiver Fig. 1. Computation offloading for an example workflow in a MEC-based UAV delivery system
Here, we illustrate the computation offloading problem with a partial workflow of the whole UAV delivery process, namely the final parcel delivery workflow. The MEC-based UAV delivery system is conceptually divided into two lay-ers. As shown in Fig. 1, the upper layer is the edge server layer, which consists of various edge servers. These edge servers can provide computing resources close to the UAV. The bottom layer is the final parcel delivery workflow which consists of a set of computation tasks with depend-encies. Generally speaking, dependencies can be generated in two situations. The first situation is where a task has one or multiple predecessors and/or successor tasks, namely they have temporal dependencies. The second situation is where data transfer is required between the two neigh-bouring tasks, namely they have data dependencies. In this paper, we simply refer them as task dependencies, and they can be explicitly specified using DAG (Directed Acy-clic Graph) as will be introduced in the next section. Specif-ically, as shown in Fig. 1, there are many computation-
UTHOR ET AL.: TITLE 3 intensive tasks in the UAV last-mile delivery scenario, for example, target detection, image segmentation, pose and face recognition. Specifically, in the real world, the video frames may contain multiple persons and hence it is neces-sary to segment the images and run multiple poses and face recognition tasks in parallel to ensure timely detection of the actual receiver from the crowd. Once the UAV de-tects the actual receiver, it will approach the receiver and begin to land and unload the parcel. Obviously, these real-time tasks are delay-sensitive, and fast response time is essential. According to different characteristics (such as task workload, data size and deadline constraints) of the com-putation tasks, some of them are offloaded to edge servers to achieve better QoS such as faster response time and low-er energy consumption [25]. However, computation of-floading is a difficult decision-making problem. While there are some existing strategies which are based on heuristic algorithms or search algorithms, they all have some limitations. For example, heuristic algorithms have the premature convergence issue so that they may not be able to find the best computation offloading decision. While search algorithms such as particle swarm optimiza-tion (PSO) and genetic algorithm (GA) can find the best decisions in theory, they are usually very time-consuming and hence not suitable for delay-sensitive applications. Meanwhile, to the best of our knowledge, none of the exist-ing strategies can effectively deal with complex task de-pendencies which can be represented by nonlinear work-flow structures such as parallel, selective and iterative structures. For solving the above issues, a novel graph-based strat-egy is proposed to solve the computation offloading prob-lem in the MEC environment. Our proposed strategy can deal with nonlinear workflow structures and find the best computation offloading decision with the minimum energy consumption under the deadline constraint.
3 P
RELIMINARIES
Generally speaking, for the purpose of computation of-floading, there are two kinds of computation tasks in the workflow, which are general tasks and local execution tasks. General tasks are those tasks which are executed either at end-device or edge server via computation of-floading. Local execution tasks are those tasks that can only be executed on end-device due to the required input data is only available at the end-device and cannot be moved due to security restrictions, or some tasks which require user input at the end-device [20]. In this situation, edge servers cannot handle these tasks. In other words, these tasks must be processed on the end-device. This paper uses the workflow dependency graph (WDG) to represent the workflow model and its task dependen-cies. WDG is a directed acyclic graph (DAG) that is com-posed of workflow tasks with dependencies. Each task 𝑇 (cid:3036) of WDG contains three basic attributes 𝑥 (cid:3036) , 𝑦 (cid:3036) , 𝑧 (cid:3036) , which represent the energy consumption in different situations of the end-device. In Fig. 2, the symbol → denotes that there is a depend-ency relationship between two task nodes. For example, the 𝑇 (cid:3036) → 𝑇 (cid:3037) , indicates that 𝑇 (cid:3036) is the predecessor of 𝑇 (cid:3037) in the WDG. There are 𝑇 (cid:2869) → 𝑇 (cid:2870) , 𝑇 (cid:2870) → 𝑇 (cid:2871) , 𝑇 (cid:2870) → 𝑇 (cid:2873) , 𝑇 (cid:2871) → 𝑇 (cid:2872) , 𝑇 (cid:2873) → 𝑇 (cid:2874) , etc. 𝑇 (cid:2869) points to 𝑇 (cid:2870) , which means there is a direct depend-ency between 𝑇 (cid:2869) and 𝑇 (cid:2870) . We use the task 𝑇 (cid:2869) ’s output data as task 𝑇 (cid:2870) ’s input data. In addition, → is defined as having transitivity, where 𝑇 (cid:3036) → 𝑇 (cid:3038) → 𝑇 (cid:3037) ⇔ 𝑇 (cid:3036) → 𝑇 (cid:3038) ⋀𝑇 (cid:3038) → 𝑇 (cid:3037) ⇔𝑇 (cid:3036) → 𝑇 (cid:3037) . The symbol ↮ indicates that there is no dependency between the two tasks, where 𝑇 (cid:3036) ↮ 𝑇 (cid:3037) means the 𝑇 (cid:3036) and 𝑇 (cid:3037) are disparate branches in WDG. For instance, we have 𝑇 (cid:2871) ↮ 𝑇 (cid:2873) , 𝑇 (cid:2872) ↮ 𝑇 (cid:2874) , etc. in Fig. 2. T T T T T T T T Fig. 2. An example workflow dependency graph
Here, 𝑥 (cid:3036) means the energy consumption of the data transmission when decide offloading 𝑇 (cid:3036) to edge server. The data transmission between 𝑇 (cid:3036) and 𝑇 (cid:3037) (MB) indicated as 𝐶𝑜𝑚𝑚(cid:4666)𝑇 (cid:3036) , 𝑇 (cid:3037) (cid:4667) . 𝑇 (cid:3036) ’s direct predecessor node is 𝑇 (cid:3037) . 𝐵𝑎𝑛𝑑𝑤𝑖𝑑𝑡ℎ is data transfer speed of the computation tasks (Mbps). 𝑃 (cid:3047)(cid:3045)(cid:3028)(cid:3041)(cid:3046) denotes the end-device’s transmission power (W). i ji trans Comm T Tx PBandwidth (cid:4666) , (cid:4667) * (1)
Where y (cid:2919) is end-device’s idle energy consumption when decide offloading T (cid:2919) to edge server. The task T (cid:2919) ’s workload (Megacycles) is denoted as l (cid:2919) . The edge server’s CPU frequency (GHz) is f (cid:2915)(cid:2914)(cid:2917)(cid:2915) . The end-device’s idle pow-er (W) is P (cid:2919)(cid:2914)(cid:2922)(cid:2915) . ii idleedge ly Pf * (2) The end-device’s load energy consumption is denoted as z (cid:2919) when T (cid:2919) is executed on the end-device. The end-device’s CPU frequency (GHz) and execution power (W) is denoted as f (cid:2915)(cid:2924)(cid:2914) and P (cid:2915)(cid:2924)(cid:2914) respectively. ii endend lz Pf * (3) In our previous work [20], the proposed method can convert the computation offloading problem of the linear WDG into the shortest path problem. There are two types of virtual nodes in the WDG, which are the start node and end node in problem of the shortest path. The weight of the edge between two nodes is expressed as 𝑤 (cid:3407) 𝑇 (cid:3036) , 𝑇 (cid:3037) (cid:3408) , which is the end-device’s energy consumption. At this time, the computation task 𝑇 (cid:3036) and 𝑇 (cid:3037) are decided offload-ing to edge server and the tasks between 𝑇 (cid:3036) and 𝑇 (cid:3037) are executed locally. All possible offloading decisions in WDG can be mapped to edges between different task nodes. The weight of each edge represents the energy consumption of end-devices. As mentioned before, the IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID energy consumptions of edge servers are not considered as edge servers are usually connected to the power grid. According to the WDG, an Energy consumption Tran-sitive Graph (ETG) is constructed. Specifically, we design a one-to-one mapping for all paths in the graph to all pos-sible offloading decisions of the workflow, and the classic Dijkstra algorithm is used to find the shortest path in ETG. Since the complexity of graph-based algorithm is low, this strategy can efficiently obtain excellent results.
4 G
RAPH - BASED M INIMUM E NERGY C ONSUMPTION C OMPUTATION O FFLOADING S TRATEGY
We present the strategy of Graph4Edge-Nonlinear in this section. This strategy will find the best offloading deci-sion with minimum energy consumption of the end-device under the given deadline. First in Section 4.1, we introduce our model definition and how to convert work-flow structure to WDG. Then in Section 4.2, we discuss how to find the best offloading decision plan for complex WDG with Graph4Edge-Nonlinear. Finally, in Section 4.3, we use pseudo-code to describe the detailed process for our strategy and the discussion of its algorithm complexi-ty is also presented.
We introduce the model definition in this section. Then the conversion from nonlinear workflow structure to WDG is described.
For the computation offloading purpose, the attributes of task 𝑇 (cid:3036) are defined as 〈𝑥 (cid:3036) , 𝑦 (cid:3036) , 𝑧 (cid:3036) , 𝑓𝑙𝑎𝑔 (cid:3036) , 𝐸 (cid:3036) 〉 . 𝑓𝑙𝑎𝑔 (cid:3036) denotes the constraint whether 𝑇 (cid:3036) is local execution task or not. Specif-ically, 𝑓𝑙𝑎𝑔 (cid:3036) (cid:3404) 1 means that 𝑇 (cid:3036) is a local execution task. Otherwise, the task 𝑇 (cid:3036) is sending to the edge server for execution. 𝐸 (cid:3036) denotes the 𝑇 (cid:3036) ’s execution energy consump-tion in end-device. The calculation method of 𝐸 (cid:3036) as fol-lows:
11 11 , ;, ;, ;, ; i i i ii i i ii i i ii i i x y ifT isoffloadedandT isnotx z ifT isoffloadedandT isnotE y ifT andT areoffloadedz ifT andT arenotoffloaded (4)
According to the offloading decision of 𝑇 (cid:3036) and 𝑇 (cid:3036)(cid:2879)(cid:2869) , the calculation method of 𝐸 (cid:3036) has two situations. When either of them offloaded, the data transmission appears between the two tasks. In this situation, the end device’s energy consumption depends on 𝑇 (cid:3036) ’s task offloading decision plan. When both of them are offloaded or not offloaded, there is no data transmission between the two tasks. The end device’s energy consumption depends on offloading decision plans of two tasks. According to the above defi-nition, the optimization goal is defined as 𝑀𝑖𝑛𝐸𝐶 , which is calculated as follows: { | } min ( ) i j iT T WDG MinEC E (5)
The final optimization goal is to find the best computa-tion offloading plan with the minimum energy consump-tion of the end-device under the deadline constraints. As shown in Fig. 3, the WDG has a sub-branch within one block. If the task offloading decision with minimum energy consumption in WDG can be found, only one branch is chosen to construct the ETG which is called “main branch” (indicated as MB). The rest of branches are called “sub-branches” (indicated as SB). such as the
𝑀𝐵 (cid:3404) (cid:4668)𝑇 (cid:2869) , 𝑇 (cid:2870) , 𝑇 (cid:2871) , 𝑇 (cid:2872) , 𝑇 (cid:2875) , 𝑇 (cid:2876) (cid:4669) and
𝑆𝐵 (cid:3404) (cid:4668)𝑇 (cid:2873) , 𝑇 (cid:2874) (cid:4669) in Fig. 3. The energy consumption of the SB in the block is mapped to the weight of the MB. The weight of the SB in Fig. 3 is defined as 𝐸 (cid:2873) (cid:3397) 𝐸 (cid:2874) . To better present our problems and methods, here are some detailed definitions. T T T T T T T T T s T e Sub Branch min(E +E )Main Branch Block
Fig. 3. An example of building ETG for single-block WDG
Block : In WDG, A block (denoted as B) is defined as a set of sub-branches which are forked from one task node and merged at another task node. A WDG with simple block
𝐵 (cid:3404) (cid:4668)𝑇 (cid:2871) , 𝑇 (cid:2872) , 𝑇 (cid:2873) , 𝑇 (cid:2874) (cid:4669) is shown in Fig. 3.
In-block edge:
In-block edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 represents the edge begins with 𝑇 (cid:3036) preceding the block, and points to 𝑇 (cid:3037) in the block, for example, 𝑒〈𝑇 (cid:2869) , 𝑇 (cid:2871) 〉 , 𝑒〈𝑇 (cid:2869) , 𝑇 (cid:2872) 〉 in Fig. 3. Formally, 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is an in-block edge, where ∃𝑇 (cid:3038) ∈ 𝑊𝐷𝐺 ∧ 𝑇 (cid:3036) → 𝑇 (cid:3038) ∧𝑇 (cid:3037) ↮ 𝑇 (cid:3038) . Out-block edge:
Out-block edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 represents the edge begins with 𝑇 (cid:3036) in the block, and points to 𝑇 (cid:3037) succeed-ing the block, for example, 𝑒〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 , 𝑒〈𝑇 (cid:2872) , 𝑇 (cid:2876) 〉 in Fig. 3. Formally, 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is an out-block edge, where ∃𝑇 (cid:3038) ∈𝑊𝐷𝐺 ∧ 𝑇 (cid:3036) ↮ 𝑇 (cid:3038) ∧ 𝑇 (cid:3037) → 𝑇 (cid:3038) . Over-block edge:
Over-block edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 represents the edge crosses over the block. 𝑇 (cid:3036) is the task node which pre-cedes the block and 𝑇 (cid:3037) is the task node which succeeds the block. For example, 𝑒〈𝑇 (cid:2869) , 𝑇 (cid:2876) 〉 , 𝑒〈𝑇 (cid:2870) , 𝑇 (cid:2876) 〉 in Fig. 3. Formally, 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is an over-block edge, where ∃𝑇 (cid:3038) , 𝑇 (cid:3035) ∈ 𝑊𝐷𝐺 ∧ 𝑇 (cid:3036) →𝑇 (cid:3038) → 𝑇 (cid:3037) ∧ 𝑇 (cid:3036) → 𝑇 (cid:3035) → 𝑇 (cid:3037) ∧ 𝑇 (cid:3035) ↮ 𝑇 (cid:3038) . Ordinary edge:
An ordinary edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 means that tasks between 𝑇 (cid:3036) and 𝑇 (cid:3037) when they are totally ordered, such as 𝑒〈𝑇 (cid:2869) , 𝑇 (cid:2870) 〉 , 𝑒〈𝑇 (cid:2871) , 𝑇 (cid:2872) 〉 , 𝑒〈𝑇 (cid:2875) , 𝑇 (cid:2876) 〉 in Fig. 3. Formally, 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is an ordinary edge, where (cid:3411)∃𝑇 (cid:3038) ∈ 𝑊𝐷𝐺 ∧(cid:4672)(cid:3435)𝑇 (cid:3036) → 𝑇 (cid:3038) ∧ 𝑇 (cid:3038) ↮ 𝑇 (cid:3037) (cid:3439) ∨ (cid:3435)𝑇 (cid:3036) ↮ 𝑇 (cid:3038) ∧ 𝑇 (cid:3038) → 𝑇 (cid:3037) (cid:3439) ∨ (cid:3435)𝑇 (cid:3035) ∈ 𝑊𝐷𝐺 ∧𝑇 (cid:3035) ↮ 𝑇 (cid:3038) ∧ 𝑇 (cid:3036) → 𝑇 (cid:3035) → 𝑇 (cid:3037) ∧ 𝑇 (cid:3036) → 𝑇 (cid:3038) → 𝑇 (cid:3037) (cid:3439)(cid:4673) . In this paper, we can define the weight of the ordinary edge as Eq. (6). i (cid:4668) | T (cid:4669) (cid:4666) , (cid:4667) k j i j j i j kTkTkWDG T T wT T y x x z (6) The topology of workflow is represented by WDG. In the real-world, the structure of workflow contains four basic topology types, viz. sequential, parallel, selective and it-
UTHOR ET AL.: TITLE 5 erative structures [11]. Specifically, in this paper, we name the workflow only composed with the sequential structure as the linear workflow. If it contains the other three structures, we name the workflow as the nonlinear structure. Although the real-world workflow structures can be very complex with the mix of the four basic work-flow structures, all of them can be converted to WDGs by a simple method are proposed in [26]. In [20], a strategy that can find minimum energy consumption of a simple linear structure workflow is proposed. However, the task dependencies in the remaining three workflow structures are much more complicated. Through the conversion pro-cess, any structures can be converted into multiple se-quential structures. Fig. 4 shows how the three nonlinear basic workflow structures are converted to WDG. T T T T T T T T T T T s T e a) parallel structure T T T T AND2‐out‐of‐3 T T T T T T T T T s T e b) selective structure T T i:=i+1 i < XOR T T s T T T T T e T T c) iterative structure Fig. 4. Convert nonlinear workflow structures to WDG As shown in Fig. 4 (a), three sequential structures are obtained by constructing three subtask instances for a parallel structure [27]. The virtual start node and end node are added to connect these sequential structures to form a complete WDG. Fig. 4 (b) and (c) show the conver- sion examples for the selective and iterative structures, respectively [7]. Any workflow is a combination of the four basic struc-tures, and they can be converted into corresponding WDG models. In real-world workflow applications, WDGs with nonlinear structures are very common [28]. Due to the existence of nonlinear structures, the existing computation offloading strategy for linear structures can-not be used directly. For solving the problem of computa-tion offloading for complex workflow applications with nonlinear structures, we propose the Graph4Edge-Nonlinear strategy. This strategy is able to optimize the end-device’s energy consumption under the given dead-line constraints.
In this section, the single-block WDG is analyzed as an example to describe the problem and the detailed steps for Graph4Edge-Nonlinear based on the above model definition. The purpose of the Graph4Edge-Nonlinear strategy is to map the energy consumption of the possible offloading decision to the weight of the edge. Therefore, the shortest path of the linear workflow structure can be easily found by the optimal offloading strategy. 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 means that tasks 𝑇 (cid:3036) and 𝑇 (cid:3037) are offloaded to the edge server, and tasks between 𝑇 (cid:3036) and 𝑇 (cid:3037) are executed locally. As a result, it is necessary to calculate the energy consumption of locally executed tasks which include transmission and idle ener-gy consumption. In the single-block WDG, Eq. (6) is suit-able for in-block edges and ordinary edges. But when 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is either out-block or over-block, Eq. (6) is no longer suitable for its weight calculation due to the tasks succeeding the block may have more than one task as their predecessor node. For example, the edge of 〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 in Fig. 3 can be calculated by 𝑤〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 (cid:3404) 𝑥 (cid:2872) (cid:3397) 𝑥 (cid:2876) (cid:3397) 𝑦 (cid:2876) (cid:3397)𝑧 (cid:2872) (cid:3397) 𝑧 (cid:2875) according to Eq. (6). However, the offloaded situa-tion of the sub-branch tasks 𝑇 (cid:2873) and 𝑇 (cid:2874) is not considered. Therefore, the obtained shortest path cannot represent the overall decision of WDG. For the above reasons, the weight of 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is defined as follows: min *(cid:4668) | (cid:4669) (cid:4668) | (cid:4669) (cid:4666) , (cid:4667) (cid:4666) (cid:4667) lk k i k j l l i j j j ik T ST T WDG T T T T T SB wT T y x xz E (7) In Eq. (7), (cid:3435)∑ 𝐸 (cid:3021) (cid:3287) (cid:4668)(cid:3021) (cid:3287) |(cid:3021) (cid:3287) ∈ SB (cid:4669) (cid:3439) (cid:3020) (cid:3288)(cid:3284)(cid:3289) means the minimum en-ergy consumption of the tasks that are in the sub-branches of the block. 𝑥 (cid:3036)(cid:2878)(cid:2869)∗ represents the transmission energy consumption of the task that directly depends on 𝑇 (cid:3036) . The out- or over-block edge’s shortest path length is equal to the task’s minimum energy consumption by Eq. 7, i.e. 𝑃 (cid:3040)(cid:3036)(cid:3041) 〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 (cid:3404) ∑ 𝐸 (cid:3038)(cid:3419)(cid:3021) (cid:3286) |(cid:3021) (cid:3286) ∈ WDG ∧(cid:3021) (cid:3284) →(cid:3021) (cid:3286) →(cid:3021) (cid:3285) (cid:3423) . Hence, in or-der to calculate the out- or over-block edge’s weights, the offloaded strategy of sub-branch in single-block WDG is essential. For instance, the weight of edge 𝑒〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 in Fig. 3 is calculated as 𝑤〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 (cid:3404) 𝑥 (cid:2872) (cid:3397) 𝑥 (cid:2876) (cid:3397) 𝑦 (cid:2876) (cid:3397) 𝑧 (cid:2872) (cid:3397) 𝑧 (cid:2875) (cid:3397) IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID (cid:4666)𝐸 (cid:2873) (cid:3397) 𝐸 (cid:2874) (cid:4667) (cid:3020) (cid:3288)(cid:3284)(cid:3289) where 𝑆 (cid:3040)(cid:3036)(cid:3041) is the best computation offload-ing decision of the SB. For any sub-branch, the offloading decision of the pre-vious node of the block decides the transmission energy consumption of the first task node in SB. If 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 is an over-block edge, we need to consider two different situa-tions. If 𝑇 (cid:3036) is the previous node of the block and it will be offloaded, then when the first task of the SB is offloaded, the transmission energy consumption is not calculated as they are both executed on the edge. Otherwise, the transmission energy consumption must be calculated when the first task of the SB is offloaded. In order to solve this problem, when 𝑇 (cid:3036) is not the previous node of the block, a special non-offloaded virtual node 𝑇 (cid:3046) ′ is added between the start node 𝑇 (cid:3046) and the first task node 𝑇 (cid:2869) , and set 𝑥 (cid:3046) ′ (cid:3404) 𝑦 (cid:3046) ′ (cid:3404) 𝑧 (cid:3046) ′ (cid:3404) 0 . In this way, we account the energy consumption for transmission of the first node of the SB. If the rest of the tasks in the block compose a linear WDG, the Graph4Edge-Linear strategy can find its minimum energy consumption decision. Otherwise, if the remaining tasks within the block still compose a complex WDG with nonlinear structures, the Graph4Edge-Nonlinear strategy must be recursively called to search the best offloading decision plan for sub-branches. T T T a T b T h T k T i T j T s T e Main Branch Sub-branch Block …………
Fig. 5. The initial ETG of single-block WDG T u T v T a T b T h T k T i T j T s T e Sub-branch Block ………… …… …… Fig. 6. Examples of in-block edges in two different situations T i T j T s T e …… (a) In-block edges not from the previous node T i T j T s' T s T e (x,y,z) s' =(0,0,0) …… (b) In-block edges from the previous node Fig. 7. Construct the ETG for branch structure For an out-block edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 , the previous task of sub-branch is unknown. For example, for calculating the out-block edge weight 𝑒〈𝑇 (cid:2871) , 𝑇 (cid:2876) 〉 in Fig. 3, the optimal of-floading decision 𝑆 (cid:3040)(cid:3036)(cid:3041) is necessary for the sub-branch (cid:4668)𝑇 (cid:2873) , 𝑇 (cid:2874) (cid:4669) . However, 𝑆 (cid:3040)(cid:3036)(cid:3041) depends on the offloaded status of 𝑇 (cid:2869) and 𝑇 (cid:2870) . Therefore, multiple ETGs for WDG must be constructed to measure the out-block edge’s weight. Spe- cifically, the minimum energy consumption strategy is the minimum length path among all ETGs. The specific steps for Graph4Edge-Nonlinear strategy are shown be-low: Step 1 : Construct the initial ETG of WDG. An arbitrary branch in WDG is chosen as the main branch. At the same time, the energy edges are added to construct ETG. And for the set of (cid:4668)𝑇 (cid:3036) |𝑇 (cid:3036) ∈ 𝑙𝑜𝑐𝑎𝑙𝑆𝑒𝑡(cid:4669) , the edges are pruned when 𝑇 (cid:3036) serves as the head or tail. Step 2 : Set the weight of edges in the ETG. The weights of the ordinary and in-block edges are set by Eq. (6). For the over-block edges, the Graph4Edge-Nonlinear strategy is recursively called to find its 𝑆 (cid:3040)(cid:3036)(cid:3041) , then set the weights by Eq. (7). Finally, the weight of all out-block edges is set to infinity. The initial ETG is shown in Fig. 5. Step 3 : Construct two different branch ETG models based on in-block edge situations. The specific description is as follows: 1)
If the in-block edge is not from the previous node of the block, and firstly discovered.
A new ETG is created, and then the Graph4Edge-Nonlinear strategy pro-cesses the sub-branch in the block to find the opti-mal energy consumption offloading decision. For example, when we find 𝑒〈𝑇 (cid:3048) , 𝑇 (cid:3028) 〉 in Fig. 6, mark the current situation and create a new ETG to record according to the current ETG. First of all, the infor-mation of the current ETG is copied to the new ETG. Then, we prune all the in-block edges which head from the previous task of this block, which ensures the correct calculation of the sub-branch’s minimum energy consumption strategy. At this time, the ETG generated by the linear branch WDG is shown in Fig. 8 (a). Finally, the weights of all out-block edges for this block in ETGs are updated. 2) If the in-block edge is from the adjacent predecessor task of block, and this situation was first discovered.
We can make adjustments in the current ETG. Specifically, when the in-block edges from the previous task node of this block were discovered for the first time, such as 𝑒〈𝑇 (cid:3049) , 𝑇 (cid:3029) 〉 in Fig. 6, situation (1) has been completely traversed, so it can be processed directly on the current ETG. Prune all in-block edges that are not from the previous task node, and it ensures that all sub-branches can be directly calculated us-ing the Graph4Edge-Nonlinear strategy. At this time, the ETG created by the linear branch WDG is shown in Fig. 8 (b). Finally, all out-block edge weights are updated for this block in ETGs. Step 4 : Use the Dijkstra algorithm to search the mini-mum length path in ETGs, and perform verification to ensure that deadline constraints are met. The nodes on the shortest path are the minimum energy consumption offloading strategy have found.
In real workflow-based applications, WDG’s structures can be complex with multiple blocks in the WDG. There-fore, Graph4Edge-Nonlinear strategy should be able to deal with multiple-blocks in the WDG.
UTHOR ET AL.: TITLE 7 T a T b T c T d T k T s T e Sub-branch Br ……… T v T w …… Sub-branch Br T u …… Block B Block B Fig. 8. WDG with multiple serial blocks T a T b T c T k T i T s T e ……… T v T w T j …… ……………… Sub-branch Br Sub-branch Br Block B Block B Fig. 9. WDG with nested branches T i T b T c T k T s T e …… T v T w … ……… ………… …… … Block Block T j T h Fig. 10. The ETG of WDG
A WDG may consist of many blocks. At first, any branch can be selected as the main branch. This main branch is used to construct the initial ETG. Then, multiple ETGs are built for different blocks. In the calculation pro-cess of out-block and over-block edge weights, two new situations need to search minimum energy consumption offloading decision for the sub-branch. 1)
WDG with multiple serial blocks.
In this situation, there is an edge that is both an out-block edge for one block and an in-block edge for another block, e.g. 𝑒〈𝑇 (cid:3030) , 𝑇 (cid:3049) 〉 in Fig. 8. In our strategy, depending on the head node of the in-block edge for B1, the offloaded strategy with the sub-branch is different. As a result, both the head node and the in-block edge weight for 𝐵𝑟 (cid:2870) will change. In order to calculate the out-block edge weight for B2, e.g. 𝑒〈𝑇 (cid:3050) , 𝑇 (cid:3038) 〉 , the offloading strategy of 𝐵𝑟 (cid:2870) for B2 must make sure, which depends on the offloading strategy of SB1 for B1. So it is necessary to find its minimum energy consump-tion offloading strategy from 𝐵𝑟 (cid:2869) of B1. 2) WDG with nested branches.
In this situation, it is nec-essary to recursively call the Graph4Edge-Nonlinear strategy to find its optimal offloading strategy. For exam-ple, 𝑒〈𝑇 (cid:3028) , 𝑇 (cid:3030) 〉 in Fig. 9 is an in-block edge of blocks B1 and B2, multiple new ETGs should be created based on the different situations of the two blocks, to find the optimal offloading strategy of sub-branches 𝐵𝑟 (cid:2869) and 𝐵𝑟 (cid:2870) . Hence it is necessary to recursively call the Graph4Edge-Nonlinear strategy for the WDG 𝐵𝑟 (cid:2869) ∪ 𝐵𝑟 (cid:2870) . The ETG for an example complex WDG is shown in Fig. 10. By recursively calling the Graph4Edge-Nonlinear strategy for the sub-branches, the minimum energy con-sumption offloading decision of the whole WDG can be found. For example, given an in-block edge 𝑒〈𝑇 (cid:3036) , 𝑇 (cid:3037) 〉 in Fig. 10, the Graph4Edge-Nonlinear strategy calculates the sub-branch (cid:4668)𝑇 (cid:3048) |𝑇 (cid:3048) ∈ 𝑊𝐷𝐺 ∧ 𝑇 (cid:3048) → 𝑇 (cid:3038) ∧ 𝑇 (cid:3048) ↮ 𝑇 (cid:3037) ∧ 𝑇 (cid:3048) ↮ 𝑇 (cid:3035) (cid:4669) , and gets the weight of out-block 𝑒〈𝑇 (cid:3035) , 𝑇 (cid:3038) 〉 . Clearly, no matter how complicated the structure of the WDG is, it can always be transformed to the linear struc- ture by calling Graph4Edge-Nonlinear strategy recursive-ly. Here, we present the pseudo-code for the Graph4Edge-Nonlinear strategy.
Strategy : Graph4Edge ‐ Nonlinear
Input : A workflow dependency graph ( 𝑊𝐷𝐺 ); local ‐ execution tasks in WDG ( 𝑙𝑜𝑐𝑎𝑙𝑆𝑒𝑡 ); The workflow task’s deadline constraint ( 𝐷𝑒𝑎𝑑𝑙𝑖𝑛𝑒 ); Output : tasks in WDG ( 𝑆 ); Compute (cid:4666)𝑥 (cid:3036) , 𝑦 (cid:3036) , 𝑧 (cid:3036) (cid:4667) for all tasks by Eq. (1 ‐ Add 𝑇 (cid:3046) , 𝑇 (cid:3032) into WDG and set attributes; if 𝑇 (cid:3046) ′ is needed then Add a virtual task 𝑇 (cid:3046) ′ succeed 𝑇 (cid:3046) and set attributes; end if if 𝑊𝐷𝐺 is linear workflow then return Graph4Edge ‐ Linear ( 𝑊𝐷𝐺 , 𝑙𝑜𝑐𝑎𝑙𝑆𝑒𝑡 , 𝐷𝑒𝑎𝑑𝑙𝑖𝑛𝑒 ); end if Get a main branch 𝑀𝐵 from 𝑊𝐷𝐺 and construct
ETG; Prune 𝑒(cid:4666)𝑇 (cid:3036) , 𝑇 (cid:3037) (cid:4667) if 𝑇 (cid:3036) or 𝑇 (cid:3037) in 𝑙𝑜𝑐𝑎𝑙𝑆𝑒𝑡 ; Set all out ‐ block edges 𝑒(cid:3435)𝑇 (cid:3036) , 𝑇 (cid:3037) (cid:3439) (cid:3404) ∞ ; Compute weight for other edges by Eq. (6 ‐ 𝐸𝑇𝐺_𝑆𝑒𝑡 = 𝐸𝑇𝐺 (cid:3036)(cid:3041)(cid:3036)(cid:3047) ; for each in ‐ block edge 𝑒(cid:3435)𝑇 (cid:3036) , 𝑇 (cid:3037) (cid:3439) in 𝐸𝑇𝐺_𝑆𝑒𝑡 do if 𝑖𝑠𝐹𝑖𝑟𝑠𝑡𝐹𝑖𝑛𝑑(cid:4666)𝑇 (cid:3036) (cid:4667) && 𝑛𝑜𝑡𝑃𝑟𝑒𝑣𝑖𝑜𝑢𝑠𝑁𝑜𝑑𝑒(cid:4666)𝑇 (cid:3036) (cid:4667) then 𝐸𝑇𝐺 (cid:3020)(cid:3032)(cid:3047) ← 𝐸𝑇𝐺 ; 𝑆 (cid:3020)(cid:3003) ← 𝐼𝑡𝑒𝑟𝑎𝑡𝑒 Graph4Edge ‐ Nonlinear; end if if 𝑖𝑠𝑃𝑟𝑒𝑣𝑖𝑜𝑢𝑠𝑁𝑜𝑑𝑒(cid:4666)𝑇 (cid:3036) (cid:4667) then 𝑆 (cid:3020)(cid:3003) ← 𝐼𝑡𝑒𝑟𝑎𝑡𝑒 Graph4Edge ‐ Nonlinear (need 𝑇 (cid:3046) ′ ); end if Compute out ‐ block edge in 𝐸𝑇𝐺_𝑆𝑒𝑡 by Eq. (7); end for for 𝑘 (cid:3404) 𝑛 (cid:3397) 1 to do 𝑃 (cid:3040)(cid:3036)(cid:3041) (cid:3404) 𝐷𝑖𝑗𝑘𝑠𝑡𝑟𝑎_𝐴𝑙𝑔𝑜𝑟𝑖𝑡ℎ𝑚(cid:4666)𝑇 (cid:3046) , 𝑇 (cid:3038) , 𝐸𝑇𝐺(cid:4667) ; 𝑆 (cid:3404) 𝑃 (cid:3040)(cid:3036)(cid:3041) (cid:4666)𝑇 (cid:3046) , 𝑇 (cid:3038) (cid:4667) traversed tasks; if 𝑤𝑜𝑟𝑘𝑓𝑙𝑜𝑤 𝑚𝑎𝑘𝑒𝑠𝑝𝑎𝑛 < 𝐷𝑒𝑎𝑑𝑙𝑖𝑛𝑒 then break; end if end for if 𝑘 (cid:3404) 0 then 𝑆 (cid:3404) 𝑛𝑢𝑙𝑙 ; end if return 𝑆 ; First, WDG is initialized (Lines 1-5). If the WDG is a linear structure, the Graph4Edge-Linear strategy is direct-ly called (Line 7). Otherwise, an arbitrary branch from 𝑇 (cid:3046) to 𝑇 (cid:3032) is chosen as the main branch, and this main branch is used to construct the initial ETG (Lines 9-10), and com-pute the weight of the ordinary, in-block and over-block edge by Eq. (6-7) (Line 12). Next, all the in-block edges are traversed in sequence. When the in-block edge of a block is found for the first time, and its head node is not the previous task for this block, a new ETG is created and added to the 𝐸𝑇𝐺_𝑆𝑒𝑡 (Lines 15-18). Then, the shortest path of the sub-branch can be found in the new ETG. When an in-block edge of which the head node is the previous task of this block is found, the current ETG is
IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID processed (Lines 19-21) to obtain the sub-branch’s optimal offloaded strategy. Meanwhile, the weight of the out-block edges is updated in
𝐸𝑇𝐺_𝑆𝑒𝑡 (Line 22). Finally, the Dijkstra algorithm can find the shortest path from 𝑇 (cid:3046) to 𝑇 (cid:3038) (Line 25). In the worst situation (Line 31), if all solutions do not meet the deadline constraints, all tasks in the workflow are executed locally. For the pseudo-code in Graph4Edge-Nonlinear, recur-sive calls (Lines 14-23) exist in the Graph4Edge-Nonlinear strategy, and the complexity of the algorithm highly de-pends on the structure of WDG. The worst time complexi-ty of initial ETG (Lines 1-5) is 𝑂(cid:4666)𝑛 (cid:2870) (cid:4667) . For each branch, a new ETG will be created for WDG (Line 16). The created ETG’s maximum number of tasks is smaller than the number of tasks in the main branch, which is n. For all ETGs, the construction of directed edges needs to be completed, and the worst time complexity of this opera-tion is
𝑂(cid:4666)𝑛 (cid:2871) (cid:4667) . Use the Dijkstra algorithm to perform the shortest path search for all ETGs when the deadline con-straint is met (Line 25), its time complexity is
𝑂(cid:4666)𝑛 ∗ 𝑛 (cid:2870) ∗ 𝑛(cid:4667) . In summary, the worst time complexity is
𝑂(cid:4666)𝑛 (cid:2872) (cid:4667) . Similar-ly, for each ETG, multiple two-dimensional arrays store the necessary information, so that the space complexity of the Graph4Edge-Nonlinear strategy is about
𝑂(cid:4666)𝑛 (cid:2871) (cid:4667) , and does not exceed
𝑂(cid:4666)𝑛 (cid:2872) (cid:4667) .
5 E
VALUATION
The Graph4Edge-Nonlinear strategy is able to find the optimal computation offloading decision with the lowest energy consumption under the given deadline constraint for a complex workflow application. In this section, we describe the simulation environment and parameter set-tings firstly. Then, we revisit our motivating example as a real-world case study to illustrate our strategy’s effective-ness. Furthermore, with simulation experiments based on a real-world UAV delivery system UAV-EXPRESS, we evaluate the performance of Graph4Edge-Nonlinear and compare with other strategies in the end-device’s energy consumption, the strategy running time and task re-sponse time. UAV-EXPRESS is developed based on EX-PRESS which is an energy-efficient and secure frame-work for MEC environment and blockchain technology-based smart systems [21]. Similar to the motivating example shown in Fig.1, Fig. 11 shows the detailed workflow for the final parcel delivery process in the UAV delivery system. Before the UAV reaches the destination for parcel delivery, the edge serv-er downloads the facial images of the parcel receiver from the cloud server of the logistics system. When the UAV arrives at the destination, the video stream captured by the camera of the UAV is analyzed frame by frame to lo-cate the position and confirm the identity of the parcel receiver. The final parcel delivery process can be described in three stages. In the first stage (including Tasks 1-3), the original video frames are filtered on the UAV. We use the . EXPRESS Framework Project at GitHub: https://github.com/ISEC-AHU/UAV-EXPRESS.git target detection function to search for video frames con-taining people, and frames without people are filtered directly. A small proportion of the images containing people in the whole video frame is further extracted by using the image segmentation algorithm according to the detected location coordinate of the people. In the second stage (including Task 4 and Task 5), extracted video frames are further processed. In a real-world scenario, there could be a lot of pedestrians near the destination, and hence there will be many images containing multiple people. We use pose recognition (i.e., the parcel recipient will receive an instruction on her/his mobile App to make a specific pose such as waving the right hand from right to left) to further identify the receiver from the crowd. Finally, in the third stage (including Task 6 and Task 7), identification of the parcel receiver is conducted using face recognition. Face recognition confirms whether the person waving hand matches the face images down-loaded in advance from the cloud server. If matches, the UAV will approach the receiver for landing and then hand over the goods. Otherwise, more image frames are processed until the correct parcel receiver is found, or the delivery process terminates without successfully locating the parcel receiver. Update order information
Store all order information ① Video frame filtering ② Target Detection ③ Image Segmentation
Edge Server
Video Data ④ Pre-processing : Normalize the split picture ⑤ Pose Recognition ⑦ Confirm the goods receiver and dispatch ⑥ Face Recognition
Images Contain People Process video frames processDownload the face images of the goods receiver from the cloud server Images Containing PeopleVideo Data Process video frames process
End device
Fig. 11. A case study on the MEC-Based UAV delivery system
For the experiment, we select a one-minute video clip, with 1920*1080 pixel and 60 FPS recorded by the DJ Ma-vic Air UAV . With our computation offloading strategy, the generated computation offloading decision is that Task 1-3 and Task 4 are to be executed locally, while Task 5 and Task 6 are to be offloaded to the edge server. Specif-ically, Task 1-3 and Task 4 are the video pre-processing tasks that can be executed on the UAV since the charac-teristic of data size but the required computing power is low. After the UAV completes the video pre-processing tasks, the remaining data size is reduced to 10% of the UTHOR ET AL.: TITLE 9 original video frames. The deep neural network-based computation tasks (Task 5 and Task 6) are executed at the edge server because the size of data transfer for Task 5-6 is very small but they both require high computing power.
In our experiments, we compare Graph4Edge-Nonlinear with three types of computation offloading strategies. The first type is based on search algorithms including PSO and GA which are most widely used for computation offloading. The second type is a Greedy strategy which makes the offloading decision for each task through com-parison the energy consumption required for offloading with local execution. If the energy consumption of task offloading is less than execution locally, then the task will be offloaded to the edge server for execution. Otherwise, the task will be executed locally. The third type is the All-in-End strategy, which means that all of the tasks are exe-cuted in the end device. All computation offloading strat-egies are applied with the Min-Min task scheduling algo-rithm [29] at the edge server. All simulation experiments are implemented on the FogWorkflowSim platform, which is a simulation plat-form for Fog/MEC-based workflow applications [22]. It supports different kinds of workflow structures and dif-ferent evaluation index metrics such as time, energy and cost. The experiments are run on a laptop with the follow-ing configuration: Intel® Core™ I7-9750H CPU 2.60GHz, 16G RAM, NVIDIA GeForce GTX 1660Ti.
TABLE 1
MEC E NVIRONMENT P ARAMETER S ETTING
Parameters End Server
Edge Server
MIPS 1000 1300 Load Power (mW) 700 N/A
Idle Power (mW) 30 N/A Data Transmission Power (mW) 100 N/A
Table 1 describes parameter settings of the MEC envi-ronment. The simulated MEC environment consists of three edge servers and one UAV as the end-device. Edge servers are deployed close to the UAV, the data transmis-sion rate between UAV and edge server is 100 Mbps [30] and the bandwidth is relatively stable. The processing speed of the computing resources is randomly chosen between 100 and 1500 Megacycles. According to the EX-PRESS framework and actual data collection in UAV last-mile delivery scenarios, the input and output data size for each task is generated between 0.625 and 30 MB random-ly [21], [31], [32]. In this paper, we only consider the ener-gy consumption of the UAV. Table 2 describes the parameter settings of PSO and GA strategy respectively [33], [34]. For each workflow application, we simulate 100 times to obtain the average result. In order to comprehensively evaluate the overall performance, we randomly generate many complex WDG of different sizes from 10 to 100 tasks with both linear and nonlinear workflow structures. The percentage of the lo-cal execution task (namely those cannot be offloaded to the edge) is set as 20%.
TABLE 2
PSO, GA S TRATEFGY P ARAMETER S ETTING
PSO GA Parameters Setting Parameters Setting Particles 30 Population Size 50 Iterations 100 Iterations 100 Factor C1, C2 2 Cross Rate 0.8 Inertia Weight 1 Mutation Rate 0.1 Repeated 10 Repeated 10
Now we present the detailed simulation results. Deadline constraint is the most important QoS constraints in any real-world business systems. According to actual business requirements, there is usually a strict time constraint. Based on the results of our actual program [21], our work-flow application’s deadline constraint is set between 70% and 140% of the total task local execution time. Note that the deadline constraint considered in this paper is the soft deadline, which means that missing the deadline will not cause task failures but only decrease the service quality. Fig. 12. Energy consumption and task’s offloading per-cent with different deadline constraints Fig. 12 shows the energy consumption results under different deadline constraints. Initially, all tasks are exe-cuted locally on the UAV. When the value of deadline constraint increases, the percentage of offloaded tasks also increases. In the meantime, the end-device’s energy consumption is gradually decreasing. It can be seen that the end-device’s energy consumption becomes stable when the deadline constraint reaches 130%. The results show that when the deadline constraint becomes more flexible, the room for the computation offloading strategy becomes larger and hence our Graph4Edge-Nonlinear strategy becomes more effective in reducing the end-device’s energy consumption. However, when deadline constraint reaches a certain value, the effectiveness of reducing energy consumption levels off since the per-centage of offloaded tasks also reaches its maximum 80% (as we have set 20% of local execution tasks). In order to compare the best performance of different computation offloading strategies, we focus on the deadline is 130% in the following experiments. To comprehensively evaluate its performance, we compare Graph4Edge-Nonlinear with others in energy consumption, strategy running time and task response time. O ff l oa d i n g t a s k s E n er gy c o n s u m p t i o n Deadline constraint
Energy Consumption Offloading Tasks
0 IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID
Fig. 13. Comparison of Graph4Edge-Nonlinear and other four meth-ods for energy consumption
Fig. 14. Comparison of Graph4Edge-Nonlinear and other four meth-ods for strategy running time
Fig. 13 shows that the end-device’s energy consump-tion of the over different sizes of nonlinear workflows. The experimental result demonstrates that energy con-sumption with Graph4Edge-Nonlinear is always lower than the other four strategies. For example, when the task number is 50, the energy consumption with Graph4Edge-Nonlinear is 7.81% and 9.51% lower than PSO and GA respectively. The Greedy strategy and All-in-End strategy always have higher energy consumption than Graph4Edge-Nonlinear which is about 94% and 310% respectively. This is because they place too many tasks on the end device for execution. Fig. 14 illustrates the results of strategy running time over different sizes of nonlinear workflows. Please be noted that the basic time units for Graph4Edge-Nonlinear, Greedy and the All-in-End strategies are milliseconds (ms), while the basic time units for PSO and GA are 100ms and 500ms respectively. Clearly, Graph4Edge-Nonlinear is much faster than search-based strategies PSO and GA. Specifically, it is running about 110 times and 540 times faster than PSO and GA respectively. In the FogWorkflowSim platform [22], All-in-End strategy run-ning needs to count the number of tasks that make up the workflow, which usually takes a few milliseconds. Alt-hough the Greedy and All-in-End strategies have the smallest execution time, it always has the worst perfor-mance in reducing energy consumption. In particular, even if the number of tasks is as high as 100, the Graph4Edge strategy only needs an additional 30ms to get the optimal offloading decision. When it is necessary to perform offloading of delay-sensitive tasks, our strate-gy can guarantee real-time performance.
Fig. 15. Comparison of nonlinear workflows and linear workflows for strategy running time
Fig. 16. Comparison of Graph4Edge-Nonlinear and other four meth-ods for task response time
It is also important to investigate the impact of work-flow structures on the strategy running time. Fig. 15 com-pares the strategy running time of Graph4Edge-Nonlinear and Graph4Edge-Linear on nonlinear work-flows and linear workflows respectively with 10 to 50 tasks. The result shows that with the same workflow sizes, the strategy running time of Graph4Edge-Nonlinear is about 20% higher than Graph4Edge-Linear, which is not a significant increase considering the much more complex structures of the nonlinear workflows. Meanwhile, even with 50 tasks, the strategy running time of Graph4Edge-Nonlinear is only increased by 2ms. Fig. 16 illustrates the results of task response time over different sizes of tasks in nonlinear workflows. The work-flow tasks are executed according to the offloading deci-sion plan. The task response time is set as the sum of task execution time and data transmission time. Obviously, our proposed Graph4Edge-Nonlinear strategy requires minimal task response time. In summary, given the ex-perimental results above, we can conclude that our pro-posed strategy has the best overall performance as it can find the optimal computation offloading decision plan with the lowest energy consumption under the given deadline. Most importantly, for delay-sensitive applica-tions, our proposed strategy can meet their real-time re-quirements given its fast running time. E n er gy c o n s u m p t i o n ( J ) Number of tasks
Graph4Edge Greedy All-in-End PSO GA01020304050 10 20 30 40 50 60 70 80 90 100 S t r a t e gy r unn i n g t i m e ( m s ) Number of tasks
Graph4Edge Greedy All-in-End PSO(x100)ms GA(x500)ms 05101520 10 20 30 40 50 S t r a t e gy r unn i n g t i m e ( m s ) Number of tasks
Nonlinear Workflow Linear Workflow0100200300400500600 10 20 30 40 50 60 70 80 90 100 T a s k re s p o n s e t i m e ( m s ) Number of tasks
Graph4Edge Greedy All-in-End PSO GA
UTHOR ET AL.: TITLE 11
6 R
ELATED W ORK
In a MEC environment, the main objective of the compu-tation offloading strategy is to find the best offloading decision according to the characteristics of tasks, compu-ting resources and network conditions [35]. In addition, these methods can improve the utilization rate of compu-ting resources in MEC [36] and minimize the end-device’s energy consumption with the QoS constraints of users and reduce the cost of the service providers [37]. Compu-tation offloading is used for solving the problems caused by insufficient computing power and insufficient battery capacity of the end-device. With the gradual promotion of MEC platform, computation offloading has become an important research topic [25]. There are many prelimi-nary research works focusing on the problem of computa-tion offloading in the MEC environment. Currently, a range of research works focuses on the problem of computation offloading to reduce end-device’s energy consumption and task response time. In the aspect of the energy consumption optimization, Zhang et al. [38] focused on the multi-access characteris-tics of the 5G and an minimize the energy consumption offloading strategy in 5G MEC networks is proposed. Chen et al. [39] consider the factor of task allocation and CPU-cycle frequency. Then, an energy efficiency strategy named TOFFEE is proposed to decrease end-device’s en-ergy consumption. For the target of time optimization, Xing et al. [40] propose a MEC system that can reduce the task’s computation latency significantly. Currently, many research works are based on popular optimization algo-rithms such as PSO and GA [33], [34]. However, most studies only focused on the independent tasks, and ig-nored the computational overhead needed to make deci-sions. Most of the tasks in real-world applications are highly correlated. Each task depends on the execution result of the previous task and provides the necessary data flow for the successor task [31], [41]. Graph as a kind of classical data structure. Many re-search works about graph-based algorithms in Cloud and Edge Computing. In the cloud computing environment, many studies adopted graph-based algorithms to solve task management problems for different workflow struc-tures. Yuan et al. [42] aimed at the problem of data set storage in data-intensive scientific workflow execution and proposed the CTT-SP algorithm to trade-off compu-tation and storage cost in the cloud environment. Zhang et al. [43] proposed a highly efficient algorithm named PCE, which can calculate the minimum cost strategy in multiple clouds efficiently. In recent years, there are also many studies in the MEC environment. Elgamal et al. [44] focused on the time and memory of the pricing model in serverless computing and proposed an algorithm to op-timize the price of AWS workflow applications while meeting deadline constraints. Khare et al. [45] focused on the data placement problem of operators in streaming applications and proposed an algorithm to convert streaming DAG into a set of approximate linear chains and perform data placement and time prediction. Most research focuses on resource management issues in cloud or edge conditions. However, these works have not paid attention to the problems of end-device’s limited compu-ting power and battery capacity in the MEC environment. In [25], the authors proposed a graph-based strategy that can provide a solution for the generation of the optimal energy consumption offloading strategy for linear work-flow, but this strategy cannot handle the nonlinear work-flow of complex applications. Therefore, this paper deals with various problems of computation offloading in the MEC environment using graph-based technology. We focus on workflow applica-tions with complex structures and propose the Graph4Edge-Nonlinear strategy as an effective solution.
7 C
ONCLUSION A ND F UTURE W ORK
Computation offloading is a key technology to optimize the QoS of MEC based applications. However, most exist-ing strategies did not pay attention to the dependency between computing tasks or only focus on simple de-pendency such as sequential relationship. Meanwhile, many current strategies are based on search algorithms which could have significant computation overhead. This is unacceptable for delay-sensitive applications. For solv-ing these problems, a novel graph-based computation offloading strategy with the goal to minimize the end-device’s energy consumption under the given deadline constraint is proposed in this paper. Motivated by a MEC-based UAV delivery system, we first built the nonlinear workflow model for complex applications. Then, using the graph-based partition technique, we proposed the Graph4Edge-Nonlinear strategy to search for the best computation offloading decision with the lowest energy consumption under the deadline constraint. Finally, both a real-world case study and comprehensive simulation experiments implemented on the FogWorkflowSim plat-form with different workflow sizes and structures are conducted to evaluate the effectiveness of our proposed strategy. The experimental results have shown that Graph4Edge-Nonlinear can achieve overall better per-formance than other representative computation offload-ing strategies. This paper mainly focused on computation offloading for workflow applications and the target of reducing end-device’s energy consumption in the MEC environment. In the future, we will investigate the problem of computa-tion offloading together with workflow scheduling at the edge servers to produce a holistic solution that can im-prove the QoS for the whole MEC-based system. Besides, the impact of the dynamics of the network and the mobil-ity of the end device will be further investigated in our future work. A CKNOWLEDGMENT
This work was supported by the National Natural Science Foundation of China (No.61972001, No.62076002), the National Natural Science Foundation of Anhui Province (No. 2008085MF194) and in part by the Humanities and Social Sciences of MOE Project No. 16YJCZH048.
2 IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID R EFERENCES [1]
R. Roman, J. Lopez and M. Mambo, “Mobile Edge Compu-ting, Fog et al.: A Survey and Analysis of Security Threats and Challenges,” Future Generation Computer Systems, vol. 78, pp. 680-698, 2018. [2]
S. Kekki, W. Featherstone, Y. Fang, P. Kuure, A. Li, A. Ranjan, et al. “MEC in 5G networks,” ETSI White Paper, vol. 28, pp. 1-28, 2018. [3]
X. Lyu, H. Tian, L. Jiang, A. Vinel, S. Maharjan, S. Gjessing, Y. Zhang, et al. “Selective offloading in mobile edge computing for the green internet of things,” IEEE Network, vol. 32, no. 1, pp. 54-60, 2018. [4]
Jiang Y. A survey of task allocation and load balancing in dis-tributed systems[J]. IEEE Transactions on Parallel and Dis-tributed Systems, 2015, 27(2): 585-599. [5]
T. Soyata, R. Muraleedharan, C. Funai, M. Kwon, and W. Heinzelman, “Cloud-vision: Real-time face recognition using a mobile-cloudlet-cloud acceleration architecture,” In Proc. IEEE Symp. Comput. Commun., Jul. 2012, pp. 59–66. [6]
Z. Kuang, L. Li, J. Gao, L. Zhao and A. Liu, “Partial offload-ing scheduling and power allocation for mobile edge compu-ting systems,” IEEE Internet of Things Journal, vol. 6, no. 4, pp. 6774-6785, 2019. [7]
W. Aalst, A. Hofstede, B. Kiepuszewski and A. Barros. “Workflow patterns,” Distributed and Parallel Databases, vol. 14, no. 1, pp. 5-51, 2003. [8]
F. Zhou, Y. Wu, H. Sun and Z. Chu, “UAV-enabled mobile edge computing: Offloading optimization and trajectory de-sign,” In 2018 IEEE International Conference on Communica-tions (ICC). IEEE Press, 2018, pp. 1-6. [9]
A. Alioua, H. Djeghri, M. Cherif, S. Senouci and Hi. Sedjel-maci, “UAVs for Traffic Monitoring: A Sequential Game-based Computation Offloading/Sharing Approach,” Com-puter Networks, vol. 177, pp. 1-16, 2020. [10]
X. Chen, “Decentralized computation offloading game for mobile cloud computing,” IEEE Trans. Parallel Distrib. Syst., vol. 26, no. 4, pp. 974–983, Apr. 2015. [11]
W. Aalst, K. M. Hee and K. V. Hee, Workflow Management: Models, Methods, and Systems, 1st ed. MIT: Cambridge, 2004, pp. 75-99. [12]
Meng J, Tan H, Li X Y, et al. Online deadline-aware task dis-patching and scheduling in edge computing[J]. IEEE Transac-tions on Parallel and Distributed Systems, 2019, 31(6): 1270-1286. [13]
F Guo, et al., "An efficient computation offloading manage-ment scheme in the densely deployed small cell networks with mobile edge computing," IEEE/ACM Transactions on Networking, vol. 6, no. 26, pp. 519-531, 2018. [14]
X Xu, et al., "An energy-aware computation offloading meth-od for smart edge computing in wireless metropolitan area networks," Journal of Network and Computer Applications, vol. 133, pp. 75-85, 2019. [15]
S Deng, et al., "Computation offloading for service workflow in mobile cloud computing," IEEE transactions on parallel and distributed systems, vol. 12, no. 26, pp. 3317-3329, 2014. [16]
L Yu, et al., "A Utility-Based Optimization Framework for Edge Service Entity Caching.," IEEE Transactions on Parallel and Distributed Systems, vol. 11, no. 30, pp. 2384-2395, 2019. [17]
Hu M, Zhuang L, Wu D, et al. Learning driven computation offloading for asymmetrically informed edge computing[J]. IEEE Transactions on Parallel and Distributed Systems, 2019, 30(8): 1802-1815. [18]
S. Gould, J. Arfvidsson, A. Kaehler, B. Sapp, M. Messner, G. Bradski, et al. “Peripheral-Foveal Vision for Real-time Object Recognition and Tracking in Video,” In 20th International Joint Conference on Artificial Intelligence. IJCAI Press, 2007, pp. 2115-2121. [19]
T. Soyata, R. Muraleedharan, C. Funai, M. Kwon and W. Heinzelman, “Cloud-vision: Real-time face recognition using a mobile-cloudlet-cloud acceleration architecture,” In 2012 IEEE Symposium on Computers and Communications (ISCC). IEEE Press, 2012, pp. 59-66. [20]
L. Fan, X. Liu, X. Li D. Yuan and J. Xu, “Graph4Edge: a graph-based computation offloading strategy for mobile-edge workflow applications,” In 2020 IEEE International Confer-ence on Pervasive Computing and Communications Work-shops (PerCom Workshops), IEEE Press, 2020, pp. 1-4. [21]
J. Xu, X. Liu, X. Li, L. Zhang, Y. Yang, “EXPRESS: An Energy-Efficient and Secure Framework for Mobile Edge Computing and Blockchain based Smart Systems,” In Proc. IEEE/ACM Int. Conf. on Automated Software Engineering (ASE), IEEE Press, 2020, pp. 1-4. [22]
X. Liu, L. Fan, J. Xu, X. Li, L. Gong, J. Grundy and Y. Yang, “FogWorkflowSim: An Automated Simulation Toolkit for Workflow Performance Evaluation in Fog Computing,” In 2019 34th IEEE/ACM International Conference on Automat-ed Software Engineering (ASE). IEEE Press, 2019, pp. 1-4. [23]
G. Gargen and C. Balakrishna, “Unmanned Aerial Vehicles (UAVs) as on-demand QoS enabler for Multimedia Applica-tions in Smart Cities,” In 2018 International Conference on Innovation and Intelligence for Informatics, Computing, and Technologies (3ICT). IEEE Press, 2018, pp. 1-7. [24]
N. Motlagh, M. Bagaa and T. Taleb, “UAV-based IoT plat-form: A crowd surveillance use case,” IEEE Communications Magazine, vol. 55, no. 2, pp. 128-134, 2017. [25]
P. Mach and Z. Becvar, “Mobile edge computing: A survey on architecture and computation offloading,” IEEE Commu-nications Surveys & Tutorials, vol. 19, no. 3, pp. 1628-1656, 2017. [26]
R. Sakellariou, H. Zhao, “A low-cost rescheduling policy for efficient mapping of workflows on grid systems,” Scientific Programming, vol. 12, no. 4, pp. 253-262, 2004. [27]
Z. Wu, X. Liu, Z. Ni, D. Yuan and Y. Yang, “A market-oriented hierarchical scheduling strategy in cloud workflow systems,” The Journal of Supercomputing, vol. 63, no. 1, pp. 256-293, 2013. [28]
J. Liu, E. Pacitti, P. Valduriez and M. Mattoso, “A survey of data-intensive scientific workflow management,” Journal of Grid Computing, vol. 13, no. 4, pp. 457-493, 2015. [29]
K. Etminani and M. Naghibzadeh. “A min-min max-min se-lective algorithm for grid task scheduling,” In 3rd IEEE/IFIP international conference in central Asia on internet, IEEE Press, 2007, pp. 1-7. [30]
R. Deng, R. Lu, C. Lai, et al., “Optimal workload allocation in fog-cloud computing toward balanced delay and power con-sumption,” IEEE Internet of Tings Journal, vol. 3, no. 6, pp. 1171-1181, 2016. [31]
J. Xu, X. Li, X. Liu, C. Zhang, L. Fan, L. Gong, et al. “Mobility-aware workflow offloading and scheduling strategy for mo-bile edge computing,” In International Conference on Algo-
UTHOR ET AL.: TITLE 13 rithms and Architectures for Parallel Processing, Springer Press, 2019, pp. 184-199. [32]
T. Zhu, T. Shi, J. Li, Z. Cai, and X. Zhou, “Task scheduling in deadline-aware mobile edge computing systems,” IEEE In-ternet of Things Journal, vol. 6, no. 3, pp. 4854-4866, 2018. [33]
A. Kaswan, V. Singh and P. Jana, “A multi-objective and PSO based energy efficient path design for mobile sink in wireless sensor networks,” Pervasive and Mobile Computing, vol. 46, pp. 122-136, 2018. [34]
H. Hallawi, J. Mehnen and H. He, “Multi-capacity combina-torial ordering GA in application to cloud resources alloca-tion and efficient virtual machines consolidation,” Future Generation Computer Systems, vol. 69, pp. 1-10, 2017. [35]
J. Hu, M. Jiang, Q. Zhang, Q. Li and J. Qin, “Joint optimiza-tion of UAV position, time slot allocation, and computation task partition in multiuser aerial mobile-edge computing sys-tems,” IEEE Transactions on Vehicular Technology, vol. 68, no. 7, pp. 7231-7235, 2019. [36]
M. Alam, M. Hassan, M. Uddin, A. Almogren and G. Fortino, “Autonomic computation offloading in mobile edge for IoT applications,” Future Generation Computer Systems, vol. 90, pp. 149-157, 2019. [37]
S. Wang, Y. Zhao, L. Huang, J. Xu and C. Hsu, “QoS predic-tion for service recommendations in mobile edge computing,” Journal of Parallel and Distributed Computing, vol. 127, pp. 134-144, 2019. [38]
K. Zhang, Y. Mao, S. Leng, Q. Zhao, L. Li, X. Peng, et al, “En-ergy-efficient offloading for mobile edge computing in 5G heterogeneous networks,” IEEE Access, vol. 4, pp. 5896-5907, 2016. [39]
Y. Chen, N. Zhang, Y. Zhang, X. Chen, W. Wu and X. Shen, “TOFFEE: task offloading and frequency scaling for energy efficiency of mobile devices in mobile edge computing,” IEEE Transactions on Cloud Computing, 2019, in Press. [40]
H. Xing, L. Liu, J. Xu and A. Nallanathan, “Joint task assign-ment and resource allocation for D2D-enabled mobile-edge computing,” IEEE Transactions On Communications, vol. 67, no. 6, pp. 4193-4207, 2019. [41]
S. Deng, L. Huang, J. Taheri and A. Zomaya, “Computation offloading for service workflow in mobile cloud computing,” IEEE Transactions on Parallel and Distributed Systems, vol. 26, no. 12, pp. 3317-3329, 2014. [42]
D. Yuan, L. Cui, W. Li, X. Liu and Y. Yang, “An algorithm for finding the minimum cost of storing and regenerating da-tasets in multiple clouds,” IEEE Transactions on Cloud Com-puting, vol. 6, no. 2, pp. 519-531, 2015. [43]
J. Zhang, D. Yuan, L. Cui and B. Zhou, “A highly efficient al-gorithm towards optimal data storage and regeneration cost in multiple clouds,” Future Generation Computer Systems, vol. 99, pp. 459-472, 2019. [44]
T. Elgamal, “Costless: optimizing cost of serverless compu-ting through function fusion and placement,” In Third IEEE/ACM Symposium on Edge Computing (SEC), IEEE Press, 2018, pp. 1-13. [45]
S. Khare, H. Sun, J. Gascon-Samson, K. Zhang, A. Gokhale, Y. Barve, et al., “Linearize, predict and place: minimizing the makespan for edge-based stream processing of directed acy-clic graphs,” In 4th ACM/IEEE Symposium on Edge Compu-ting, ACM Press, 2019, pp. 1-14.
4 IEEE TRANSACTIONS ON JOURNAL NAME, MANUSCRIPT ID
Xuejun Li (Member, IEEE) received the Ph.D. degree in computer application technology from the School of Computer Science and Technology, Anhui University, Hefei, Anhui, China, in 2008. He is currently a Full Professor with the School of Computer Science and Technology, Anhui Univer-sity, Hefei, Anhui, China. His major research inter-ests include mobile edge computing, workflow systems, cloud computing, and intelligent software.
Tianxiang Chen received the bachelor's degree in Internet of Things technology from the School of Computer Science and Technology, Fuyang Nor-mal University, Fuyang, Anhui, China, in 2018. He is currently pursuing the master's degree with the School of Computer Science and Technology, Anhui University, Hefei, Anhui, China. His current research interests include mobile edge computing, workflow system, cloud computing, resource man-agement.
Dong Yuan (Member, IEEE) received the BEng and MEng degrees from Shandong University, Jinan, China, in 2005 and 2008, respectively, and the PhD degree from Swinburne University of Technology, Melbourne, Australia, in 2012, all in computer science. He is a senior lecturer with the School of Electrical and Information Engineering, the University of Sydney, Sydney, Australia. His research interests include cloud computing, parallel and distributed systems, scheduling and resource management, deep learning, data management and Internet of Things.
Jia Xu (Student Member, IEEE) received the bachelor's and master's degree in computer sci-ence and technology from the School of Computer Science and Technology, Anhui University, Hefei, Anhui, China, in 2010-2017, respectively. He is currently pursuing the Ph.D. degree with the School of Computer Science and Technology, Anhui University, Hefei, Anhui, China. He was a Software Engineer focusing on industrial projects and solutions in iFLYTEK Co., Ltm from 2017-2018. His current re-search interests include mobile edge computing, workflow system, cloud computing, resource management.
Xiao Liu (Senior Member, IEEE) received the bachelor's and master's degrees in information management and information system from the School of Management, Hefei University of Tech-nology, Hefei, China, in 2004 and 2007, respec-tively, and the Ph.D. degree in computer science and software engineering from the Faculty of In-formation and Communication Technologies, Swinburne University of Technology, Melbourne, Australia, in 2011. He was teaching at the Software Engineering Institute, East China Normal University, Shanghai, China. He is cur-rently a Senior Lecturer with the School of Information Technology, Deakin University, Melbourne. His current research interests include software engineering, distributed computing, and data mining, with special interests in workflow systems, cloud/fog computing, and social networks.(Senior Member, IEEE) received the bachelor's and master's degrees in information management and information system from the School of Management, Hefei University of Tech-nology, Hefei, China, in 2004 and 2007, respec-tively, and the Ph.D. degree in computer science and software engineering from the Faculty of In-formation and Communication Technologies, Swinburne University of Technology, Melbourne, Australia, in 2011. He was teaching at the Software Engineering Institute, East China Normal University, Shanghai, China. He is cur-rently a Senior Lecturer with the School of Information Technology, Deakin University, Melbourne. His current research interests include software engineering, distributed computing, and data mining, with special interests in workflow systems, cloud/fog computing, and social networks.