A Sufferage offloading tasks method for multiple edge servers

Abstract

The offloading method is important when there are multiple mobile nodes and multiple edge servers. In the environment, those mobile nodes connect with edge servers with different bandwidths, thus taking different time and energy for offloading tasks. Considering the system load of edge servers and the attributes (the number of instructions, the size of files, deadlines, and so on) of tasks, the energy-aware offloading problem becomes difficult under our mobile edge environment (MCE). Most of the past work mainly offloads tasks by judging where the job consumes less energy. But sometimes, one task needs more energy because the preferred edge servers have been overloaded. Those methods always do not pay attention to the influence of the scheduling on the future tasks. In this paper, first, we try to execute the job locally when the job costs a lower energy consumption executed on the MD. We suppose that every task is submitted to the mobile server which has the highest bandwidth efficiency. Bandwidth efficiency is defined by the sending ratio, the receiving ratio, and their related power consumption. We sort the task in the descending order of the ratio between the energy consumption executed on the mobile server node and on the MD. Then, we give a "suffrage" definition for the energy consumption executed on different mobile servers for offloading tasks. The task selects the mobile server with the largest suffrage. Simulations show that our method reduces the execution time and the related energy consumption, while keeping a lower value in the number of uncompleted tasks.

1. Introduction

Mobile devices bring great convenience to people’s life [1]–[3] But the limitation in processing ability and energy supply hinders its usage [4]. Offloading some tasks to remote mobile servers is a solution to overcome those shortcomings [5]–[9]. The Offloading method brings two benefits for the mobile device (MD): improving the processing ability and reducing energy consumption. It makes that the MD overcomes overloaded when it has a higher system load. With the help of the remote servers, the MD also can reduce the energy consumption in some cases.

Several prototype systems have been used to offload tasks for MDs [1]–[3], [10]–[12] with different targets and different environments. The target of offloading tasks from local to a server includes: reducing the energy consumption of the MD, shortening the execution time, and meeting other QoSs (Quality of Services) [13]–[15]. If the execution location is select smartly, energy consumption can be reduced while keeping other requirements[16], [17]. How select the execution location is the key problem for offloading tasks for MDs. The network also influences the energy consumption for offloading tasks, because the different network has different bandwidth and energy consumption, which influences the execution time for transferring files and the related energy consumption. The dynamic network makes whether offloading has a different effect on the MD of the energy consumption, execution time, and so on. Prior work has been widely evaluated in various networks, such as 2G/3G/4G/5G network [7], [8], [18]–[20].

Previous offloading methods always begin with judging the location where the task has lower energy consumption [2], [21]. Then, according to the deadline of tasks, the bandwidth between the MD and the offloaded target location, the system load of the MD and remote server, the scheduling method selects the execution location [8], [17], [22]. They always judge the preferring location of a task and offload tasks according to the preferring locations. Different routes have various energy efficiencies (sending power consumption/sending rate, or receiving power consumption/receiving rate). This is the first aspect that we try to pay attention to in this paper. If we can offload to many mobile servers make the offloading problem more difficult. Moreover, the past methods always neglect the fact that the task influences each other. For example, if a task executed on the MD consumes lower energy than in the mobile cloud (2 energy on the MD and 3 energy on the offloaded location), but the next task (1 energy on the MD and 10 energy on the offloaded location) may not be executed on the MD because of the system load. The condition happens more usually in the many (mobile nodes)-to-many (mobile servers) environment. In this paper, we try to offload tasks in a many-to-many environment by considering the scheduling influence of tasks on each other.

We organize the paper as follows. Section 2 reviews the offloading methods in mobile environment. In Section 3, we give the system architecture and related models used in our paper. Section 4 gives a deep analysis of our system, and then gives the offloading method. Section 5 compares our proposed method with other methods. Section 6 gives the conclusion and the future work.

2. Related work

Offloading methods help MDs to enhance processing ability and lengthen the working time. Researchers have much work on offloading methods under various environments.

Most offload methods are heuristics algorithms [5], [6], [10], [18], [20], [23]–[28]. B. Li et al. [20] study offload method when the application belongs to computation-intensive applications. MinHop, MET and METComm heuristics were used to offload tasks when the task dynamically arrives independent. L.Yang et al. [24] formulated the offloading problem into an energy-consuming (EC) minimization problem while meeting other constraints. They used ASO and Pro-ITGO to offload tasks. The ASO algorithm is a lightweight linear programming algorithm with three steps: sub-deadline allocation, topology sorting, and task offloading sub-algorithms. The proposed algorithm derives from the original ITGO (Invasive Tumor Growth Optimization) algorithm. Y. Li et al. [5] gave the scheduling target function according to the delay limitation by the potential game equation, and the MD selects MEC nodes according to the game results to offload tasks. For 5G heterogeneous wireless network, S. Han [29] proposed a offload algorithm with a congestion-aware WiFi environment. He proposed a distributed algorithm target to maximizing network utility. Y. Hao et al. [30] given tasks different priorities for offloading tasks according to the energy consumption and urgency. They [6] also consider how to immigrate VMs when every node has the ability to collect green energy. They used the clustering method to decide the location of the VM. And then they proposed a heuristic algorithm to transfer energy, immigrate VM, and allocate tasks. Li Kuan et al. [18] took account of multiple users, multiple offloading points, and structured tasks for offloading tasks. They used genetic algorithm with a greedy strategy to handle the offload tasks. More work can be found in [15,2934]. Generally speaking, those methods are giving the scheduling targets and finding some heuristics algorithm to meet their scheduling targets. They always pay attentions to the 1-to-1 (one MD and one mobile servers) or 1-to-many environment (one MD and many mobile servers), and proposed methods to offload tasks. Different from the above methods, we pay attention to a many-to-many environment.

Some offloading methods are two or more methods working together to complete the offloading problem. Y. Cui et al. [27] focus on the offloading problem under multi-user and dynamic environments. They tried to solve channel allocation, and offload the computation tasks with an evolutionary game model. They designed an evolutionary game algorithm based on reinforcement learning to offload tasks. W. Tang et al. [4] firstly modeled geo-distributed mobile edge servers in a peer-to-peer networks. Then, they gave offload method consider deadline, cost and so on. The method aims to improve the offloading efficiency while meeting their deadlines.

Some research also finds the offloading method by reinforcement learning methods [21], [25], [27], [28]. M. Hossain et al. [28] used an optimal binary computational offloading decision method to define the offloading problem and then solve the problem by reinforcement learning. Q. Qi et al. [25] formulated the offloading decision for multiple tasks considering a long-term time. They used the recent deep reinforcement learning to solve the offloading problem. The method scruples the future data dependence and continually online learning to improve its performance. J. Wang et al. [37] focused on the offloading problem of the vehicular user (VU) in MEC-enabled vehicular networks. They optimized the offloading problem by considering the time and the energy consumption for transferring files, and local DVFS attributes of local devices. H. Lu et al. [38] focused the offloading problem in the larges-cale heterogeneous mobile edge computing environment. They supposed that there are multiple service nodes and the tasks are independent to each other. They solved the offloading problem by using the LSTM network layer and the candidate network set to offload tasks in ab environment of the MEC. Other methods based on reinforcement learning can be found in [39], [40]. In the Vehicular ad-hoc network (VANET), U Maan et al. [41] tried to offload tasks by the estimation of vehicles’ future locations. They used Kalman filter prediction scheme to estimate the vehicle’s next location and deep Q network-based reinforcement learning to select the resources-rich fog node in VANET. Those reinforcement learning based offloading methods always give offload method from the view of task. They neglect the fact that a task is offloaded or not to the remote cloud influences the system load of the cloud and the MD, thus influencing whether the coming task can be offloaded to the remote cloud. We try to consider the influence in the paper.

With more attention having been given to the offloading problem in MCE, researchers give new directions to the scheduling targets, such as cost, security, and so on[1], [2], [14], [19], [20], [24]. Those are not related to our paper. Therefore, we do not try to introduce them here.

3. System framework and the related models

In this section, the system framework and the related models are introduced as follows.

3.1 The framework of offload tasks from a MD to remote servers

In Fig. 1, there are three mobile servers (mobile servers 1~3) and four MDs (MDs 1~4). A MD connects with multiple mobile servers, such as the MD 1 can connect with mobile servers 1~3 with different bandwidths. Different routes between MDs and mobile servers have different metrics in sending/receiving rate, sending/receiving power consumption. So, in scheduling, how to select routes is one of the most important issues to ensure a lower energy consumption for the MD.

Fig. 1. Multiple MDs and multiple mobile servers

The architecture involved in our paper includes four components (Fig. 2): tasks, the mobile server manager, the mobile manager, and cloud resources. When the MD gets a task, the mobile scheduling manager will select the execution location according to the offloading method. However, the execution location is based on multiple facts, including the bandwidth between MDs and the remote mobile server, the energy consumption in various places, and other requirements of users. The mobile server manager (MSM) collects the information of jobs and monitors the system load of the remote mobile server, and also allocates the mobile server for offloading jobs submitted from a MD. The MSM selects a mobile server for every job according to the energy consumption on various remote mobile servers and the system load. It even adds resources dynamically to the system when it is overloaded. With the help of virtualization technology, MSM can add more VMs (as mobile servers) to the system if the system needs.

Fig. 2. The framework of offloading tasks

3.2 The related models

Table 1 lists all parameters used in the paper. ND is the number of MDs, NS is the number of mobile servers. For the job Jⁱ_nd located on ndth MD, DTⁱ_nd is the deadline of the job. Aⁱ_nd is the arriving time. INⁱ_nd and OUTⁱ_nd are the size of input files and output files. NIⁱ_nd is the number of instructions (million instructions (MI)).

Jⁱ_nd = {INⁱ_nd, OUTⁱ_nd, Aⁱ_nd, DTⁱ_nd, NIⁱ_nd, LCⁱ_nd}       (1)

Table 1. Metrics used in our paper:

In formula (1), LCⁱ_nd denotes the execution place. If it equals 0, job Jⁱ_nd is executed on the ndth MD; otherwise, it denotes the selected remote mobile server. CP_nd is the computing power consumption of the ndth MD. As to formula (2), it is always denoted by a map between computing voltage V^l_nd, power consumption E^l_nd and processing ability P^l_nd. MP_nd is the number of mapping sets.

CP_nd=<V^l_nd, E^l_nd, P^l_nd>       (2)

For mobile server S_ns, NC_ns is the number of cores in 𝑛𝑛𝑛𝑛th mobile server, PA_ns is the processing ability of every core in nsth mobile server, L_ns is the system load of the mobile server.

S_ns = {NC_ns, PA_ns, LS_ns}       (3)

The total computational ability of the mobile server is P_ns, denoted as follows:

P_ns = NC_ns * PA_ns       (4)

B(nd, ns) is the bandwidth between ndth MD and nsth mobile server.

For the job Jⁱ_nd, let function checkl(Jⁱ_nd) return whether it has been completed; function eg(Jⁱ_nd) is the energy consumption of job Jⁱ_nd, so,

Maximizing:

Tar₁ = Σcheckl(Jⁱ_nd)       (5)

Tar₂ = Σ(INⁱ_nd + OUTⁱ_nd) * checkl(Jⁱ_nd)       (6)

Tar₃ = ΣNIⁱ_nd * checkl(Jⁱ_nd)       (7)

Minimizing:

Tar₄ = Σcheckl(Jⁱ_nd) * eg(Jⁱ_nd)       (8)

Subject to:

LS_ns≤ 1       (9)

LD_nd≤ 1       (10)

For eg(Jⁱ_nd), the energy consumption on the MD (when it is executed on the MD) and the energy for transferring files (when it is offloaded to a mobile server) are two important factors for offloading tasks. We do not consider the energy consumption for computation on the mobile server. We have four targets in the scheduling: maximizing the number of completed jobs (formula (5)), maximizing the size of input files and output files (formula (6)), maximizing the completed instructions (formula (7)) and minimizing the total energy consumptions (formula (8)). Formulas (9) and (10) to ensure every MD and every mobile server is not overload in the scheduling.

When Jⁱ_nd is executed on the MD, the execution time etⁱ_nd and the energy consumption ec_ndⁱ (MD working on sellth) are:

\(\begin{aligned}e t_{n d}^{i}=\left\{\begin{array}{cc}\frac{N I_{n d}^{i}}{P_{n s}} & \text { if } L C_{n d}^{i}==0 \\ \frac{I N_{n d}^{i}}{S R(n d, n s)}+\frac{o U T_{n d}^{i}}{R R(n d, n s)}+\frac{N I_{n d}^{i}}{P_{n d}^{s e l}} & \text { if } L C_{n d}^{i} \neq 0 .\end{array}\right.\\\end{aligned}\)       (11)

\(\begin{aligned}e c_{n d}^{i}=\left\{\begin{array}{cc}\frac{N I_{n d}^{i}}{P_{n s}} * N C_{n s} * P_{n d}^{s e l l} & \text { if } L C_{n d}^{i}==0 \\ \frac{I N_{n d}^{i}}{S R(n d, n s)} * S E(n d, n s)+\frac{o U T_{n d}^{i}}{R R(n d, n s)} * R E(n d, n s) & \text { if } L C_{n d}^{i} \neq 0 .\end{array}\right.\\\end{aligned}\)       (12)

In formula (12), suppose that we select the sellth working stage of the MD.

4. An offload heuristic to offload tasks from multiple mobile nodes to mobile servers

In this section, first, we give the offload method to the MD, and then we analyze the complexity of the proposed method.

4.1 Scheduling method for the mobile nodes and mobile servers

As mentioned in formula (12), we get energy consumption when a job is executed on the MD (ecdⁱ_nd) (Formula (13)) and on the mobile server (ecsⁱ_nd) (Formula (14)):

\(\begin{aligned}e c d_{n d}^{i}=\frac{N I_{n d}^{i}}{P_{n s}} * N C_{n s} * P_{n d}^{s e l l}\\\end{aligned}\)       (13)

\(\begin{aligned}e c s_{n d}^{i}=\frac{I N_{n d}^{i}}{S R(n d, n s)} * S E(n d, n s)+\frac{o U T_{n d}^{i}}{R R(n d, n s)} * R E(n d, n s)\\\end{aligned}\)       (14)

We judge the preferring location by judging etdⁱ_nd and ecdⁱ_nd which has a lower value. We also take account of the execution time on the MD (etdⁱ_nd) and the mobile server (etdⁱ_nd):

\(\begin{aligned}etd_{n d}^{i}=\frac{N I_{n d}^{i}}{P_{n s}}\\\end{aligned}\)       (15)

\(\begin{aligned}e t s_{n d}^{i}=\frac{I N_{n d}^{i}}{S R(n d, n s)}+\frac{O U T_{n d}^{i}}{R R(n d, n s)}+\frac{N I_{n d}^{i}}{P_{n d}^{S e l l}}\\\end{aligned}\)       (16)

From the above analysis, if ecsⁱ_nd is more than ecsⁱ_nd, the job Jⁱ_nd prefers to select the remote server, otherwise, the job prefers to execute on the mobile node. The problem is formulas (14) and (15) have different values when the MDs select different mobile servers (different routes have different bandwidth and energy consumption for transferring files). Here we give a parameter band(nd, ns) to illustrate the bandwidth efficiency:

band(nd, ns) = SE(nd, ns)/SR(nd, ns) + RE(nd, ns)/RR(nd, ns)       (17)

And another parameter ecrⁱ_nd to illustrate the energy consumption efficiency on the MD and the mobile server:

ecrⁱ_nd = ecdⁱ_nd/ecsⁱ_nd       (18)

For every MD, we suppose that every MD connects with the mobile server with the highest bandwidth efficiency (band(nd, ns)), the saving energy is:

secⁱ_nd = ecdⁱ_nd - ecsⁱ_nd       (19)

For every MD (nd), we have such targets:

Maximizing:

ta₁^nd = Σ_isecⁱ_nd * JLⁱ_nd       (20)

ta₂^nd = Σ_iecrⁱ_nd * JLⁱ_nd       (21)

Subject to:

LS_nd ≤ 1       (22)

Formulas (20) and (21) are the total energy consumption efficiency and the total energy saving. For the job Jⁱ_nd in the MD (nd), JLⁱ_nd denotes the execution location, if it is, JLⁱ_nd equals 1, otherwise, it is 0. So, the problem becomes a 0-1 integer programming problem.

To reduce the complexity of the problem, we first use FCFS policy for the jobs when the system load (LS_nd) of the MD is less than α. We rank every job in every MD according to the ascending order of ecrⁱ_nd, and schedule the job as FCFS policy until the system is more than α. When the system load is more than α, we use the 0-1 integer programming to solve the scheduling problem. Algorithm 1 gives the details:

Algorithm 1: Sch-Device()

1: For each MD (nd)

2: Rank jobs in every MD according to the descending order of ecrⁱ_nd;

3: While LS_nd ≤ α

4: Schedule the first job and update the system load LS_nd of the MD

5: Endwhile

6: EndFor

7: While (all MD is overload) or (all tasks have been completed)

8: For MD 𝑛𝑛𝑛𝑛 in ND

9: Solve the scheduling problem in formulas (20) to (22) as a 0-1 programming problem;

10: For every job in MD nd

11: If JLⁱ_nd == 1

12: Schedule job Jⁱ_nd on the MD;

13: EndIf

14: EndFor

15: EndFor

16: EndWhile

In algorithm 1, first of all, we rank jobs in every MD according to the descending order of ecrⁱ_nd(Line 1, in algorithm 1; same in the following paragraph). Then, we select job one by one until the system load is more than α (lines 2~5). Then, we use the 0-1 programming method to schedule jobs (line 9). Our targets include formulas (20) and (21). If JLⁱ_nd equals 1, the job will be executed on the MD (line 12); otherwise, we drop and send it to the waiting list to be processed on mobile servers.

After that, all jobs need to be offloaded to a mobile server and the problem is how to select which mobile server. Here, we take a suffrage policy: we check every job in the scheduling to find the lowest value of etsⁱ_nd (denoted as ets1ⁱ_nd), and the second-lowest value etsⁱ_nd(denoted as ets2ⁱ_nd):

sufⁱ_nd = ets2ⁱ_nd - ets1ⁱ_nd       (19)

We select the job with the maximizing sufⁱ_nd, and allocate the job to the related mobile server. Algorithm 2 gives the detail.

Algorithm 2: Sch-jobs()

1: massuf = 0;

2: While the job list is not NULL

3: For every job Jⁱ_nd in the job list

4: Get the lowest value of etsⁱ_nd (denoted as ets1ⁱ_nd) when it is offloaded to the mobile server ms₁;

5: Get the second lowest value of etsⁱ_nd (denoted as ets2ⁱ_nd) when it is offloaded to the mobile server ms₂;

6: temp = ets2ⁱ_nd − ets1ⁱ_nd;

7: If temp > massuf

8: massuf = temp;

9: selj = Jⁱ_nd;

10: self = ms₁;

11: EndIf

12: EndFor

13: Allocate selj to sels.

14: Update the system load of every mobile server.

15: EndWhile

In Algorithm 2, mssuf(Line 1, Algorithm 2; same in the following paragraph) is used to record the maximizing Sufferage [42] of Formula (19). Lines 4 and 5 find the lowest etsⁱ_nd and the second lowest etsⁱ_nd, denoted by ets1ⁱ_nd and ets2ⁱ_nd. Line 6 gets the difference between ets1ⁱ_nd and ets2ⁱ_nd. Lines 7~11 find the job with the lowest sufⁱ_nd. selj and sels are the selected job and the selected mobile server. Line 13~14 allocate the selected job selj to the selected mobile server sels, and then update the system load of the selected mobile server.

4.2 Complexity analysis

Algorithm 1 has two parts: lines 1-6 and lines 7-16. For the first part, the complexity of lines 1-6 is O(max (NT_nd)); NT_nd is the total number of tasks in ndth MD. For the second part, because the task that can be allocated to a mobile node is a constant (ensuring the system load is less than α), the complexity of line 9 is O(1). So, the complexity of the second part is O(1 ∗ ND). Thus:

O(Algorithm 1) = O(max(NT_nd)) + O(ND)

For Algorithm 2, line 4 and line 5 have the same complexity: O(max(NT_nd)). Line 3 also has a complexity of O(max(NT_nd)). So, the complexity of Algorithm 2 is:

O(Algorithm 1) = O(max(NT_nd) ∗ max(NT_nd))

In conclusion, the complexity of our algorithm is:

O = O(max(NT_nd)) + O(ND) + O(max(NT_nd) ∗ max(NT_nd)) = O(ND) + O(max(NT_nd) ∗ max(NT_nd))

5. Simulations and comparisons

5.1 Simulation environment

The parameters in the simulation environment are given in Table 2. We suppose that the system has 20000 jobs, and the number of instructions of each job is a random in [[1 100000]MI (Million instructions). The file size of the input and output files is in the scope of [0 1000]M. Each MD has 4 cores and each has a random computing speed in 1800~2200MHz. The working power consumption of the MD is random in 0.4~0.6W and the idle power consumption is 0.001W. Each mobile server has 16 cores and each has a random computing speed in 2000~3000 MHz. The sending rate between the MD and mobile server is a random number in 6~8M/s and the receiving rate is a random number in 10~20 M/s. The average power consumption for receiving data and average power consumption for sending data is 0.05W and 0.1W. The deadline of jobs is 1.4~1.8 (Random) times of the execution time. All the results are the average value of 100 times. The average arrival rate (AAR) (per. hour) is changed from 400 to 500 with a step of 10. There are 10 MDs and 10 mobile servers in the simulation environment. We will evaluate five metrics of the four methods: AET (Average execution time), NCJ (Number of completed jobs), AEC (Average energy consumption), NOI (number of instructions of completed tasks) and FS (files size of completed jobs). According to the parameters used in Table 1, the five metrics are given as follows:

NCJ = ∑_i∑_ndFⁱ_nd

AET = ∑_i∑_ndETⁱ_nd/NCJ

AEC = ∑_i∑_ndECⁱ_nd/NCJ

NOI = ∑_i∑_ndFⁱ_nd * NIⁱ_nd/NCJ

FS = ∑_i∑_ndFⁱ_nd * (OUTⁱ_nd + INⁱ_nd)/NCJ

Table 2. Parameters used in the simulation

5.2 Comparisons and discussions

We will compare our method with Tradeoff (TDO) [43]–[45], adaptive offloading (AO) [16] and Dynamic Programming-based Energy Saving Offloading (DPESO) algorithm [46]. DPESO gave the offloading method by considering the offloading option, offloading sequence and transmission power by judging the location where the job saves more energy. The TDO is an intelligent computation offloading system that makes tradeoff decisions for code offloading from the MD to the cloud to reduce energy consumption. AOD uses a fitness function to evaluate the offloading scheme. We will compare those four methods in the following metrics: number of un-completed jobs (NUJ) (Fig. 3), average energy consumption (AEC) (Fig. 4), average execution time (AET) (Fig. 5), number of instructions of completed tasks (NOI) (Fig. 6) and files size of completed tasks (FS) (Fig. 7). We call our method as “Sufferage” in the simulation which includes Algorithm 1 and Algorithm 2.

Fig. 3. AET under different AARs

Fig. 4. AEC under different AEC

Fig. 5. NUJ under different AARs

Fig. 6. NOI under different AAR

Fig. 7. SF under different AAR

Fig. 3 is the AET of DPESP, AO, and TDO. Sufferage always has the lowest value in AET under any AARs. The AET of Sufferage, DPESP, AO, and TDO is 6.3528 (s), 6.8672 (s), 7.4151 (s), and 7.6302 (s), respectively. Fig. 4 is the AEC of those methods when AARs are changed from 400 to 500 with a step of 10. The ascending order of AECs of those four methods is Sufferage, DPESP, AO, and TDO. To AECs of DPESP, AO, and TDO, Sufferage average reduces 0.3314, 0.2479, and 0.6191, about 10.39%, 8.43%, and 24.09%. Sufferage performs best in AEC and AET because the scheduling algorithm in the MD ensures the lowest cost and the scheduling algorithm in the mobile server considers the future influence on the scheduling order. When Sufferage offloads tasks, it makes that the task has a lower execution time and energy consumption when the task is executed on the MD. Moreover, when the task is offloaded to the mobile server, it considers the influence of scheduling tasks. Other methods just consider the scheduling result and give a static judgment (such as tradeoff, fit function, and others) for the scheduling. Therefore, sometime, the scheduling of some tasks makes the coming tasks do not have a lower energy consumption in the future.

Fig. 5 is the NUJ of those four methods under different AARs. Sufferage always has the lowest value in NUJs, followed by DPESP, AO, and TDO. To the NUJ of DPESP, AO and TDO, Sufferage average reduces 206.6804, 413.2690, and 1072.8, about 14.40%, 25.17% and 46.61%. Fig. 6 and Fig. 7 are the NOI and FS of all methods. In general, the four methods in Fig. 6 and Fig. 7 have the same trend with NUJ in Fig. 6. Compared to NOI of DPESP, AO and TDO, Sufferage average reduces (in billion MI) 2.4794, 2.5434 and 0.2954, respectively. Compared to SF of DPESP (Fig. 7), AO and TDO, Sufferage average reduces (in ten thousand M) by 7.5965, 4.1228e and 1.5004, respectively. Generally speaking, all those methods have an increasing trend in NUJ (Fig. 3), AET (Fig. 5) and AEC (Fig. 4), and have a decreasing trend in NOI (Fig. 6) and FS (Fig. 7) with the enhancement of AARs. With the enhancement of AARs, the system has a higher system load, more tasks cannot be completed before their deadlines, thus enhancing NUJ and decreasing FS and NOI. It also makes the system have a larger value in AET and ACE. Sufferage makes full of use local and the mobile server resources, thus having a minimum value in NUJ. At the same time, when the total number of tasks is a constant, Sufferage may have the highest value in NI and FS.

6. Conclusion and future work

In this paper, we focus on the offloading problem when there are multiple MDs and multiple mobile servers. Based on the analysis, first, we select the tasks executed on the MD according to the ration between the energy consumption on the MD and the remote cloud; for the task executed on the cloud, we propose a suffrage heuristic to offload tasks and select the mobile server. Simulation results show that our proposed method improves the number of completed jobs, and reduce energy consumption. We know that the mobile node may have the ability to harvest energy, so how to use the energy and reduce the energy consumption from other system is the two key problems. We may pay some attention to the new environment and give offloading method. As to the future work, we may use Image Retagging technology [47], [48] to manage the network of the MD for task offloading.