IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO.

6, 15 MARCH 2023 4907

Auction-Based Dependent Task Offloading

for IoT Users in Edge Clouds
Jiagang Liu , Yongmin Zhang , Senior Member, IEEE, Ju Ren , Senior Member, IEEE,
and Yaoxue Zhang, Senior Member, IEEE

Abstract—The rapid proliferation of latency-sensitive Internet I. I NTRODUCTION

of Things (IoT) applications boosts the frequency of offloading
APID advances of Internet of Things (IoT) promote the
compute-intensive tasks from IoT users to mobile edge comput-
ing (MEC) due to the limitation resources of IoT devices. It is
inevitably for IoT users to compete for the computing resources
R proliferation of a variety of latency-sensitive IoT applica-
tions, such as gesture/face recognition, healthy monitoring, and
of the MEC, especially when the computation tasks are depen- augment reality. These applications are generally composed of
dent and have hard deadline constraints. However, most existing many compute-intensive tasks with dependent relationships,
dependent task offloading schemes may not well consider the
resource competition issues among IoT users, and possibly lead which can be denoted by the direct acyclic graph (DAG)
to limited system performance in multiuser scenario. To address model [1], [2], [3], [4]. Due to the limited resources of IoT
this issue, we intend to design an auction-based dependent task- users, it is very difficult to execute such applications locally
offloading mechanism to improve the efficiency of task offloading with high performance [5]. Thanks to cloud computing and
for multiple IoT users. First, we formulate the dependent task
offloading as a valuation maximization problem in the trade
computing offloading technology, the computation tasks of IoT
of computing resources satisfying users’ latency requirements, applications can be offloaded to the remote cloud for process-
which has been proved to be NP-hard. Then, by jointly consid- ing, such that the user experiences can be guaranteed [6], [7].
ering the task graph structure and the current status of the MEC, However, since a lot of data should be transmitted from IoT
we propose a truthful auction mechanism, named greedy winner users to the remote cloud via the core network, it is inevitable
selection strategy, in which a heuristic dependent task assign-
ment for winners is designed to improve the efficiency of the for the IoT user to suffer a high and unstable transmission
task offloading. By conducting extensive simulations, we validate delay, which may downgrade the user experiences.
that the performance of the proposed dependent task offloading Benefited from the rise of mobile edge computing (MEC),
strategy is superior to existing competition algorithms, in terms many small-scale servers are deployed at the edge of the mobile
of total valuations, average makespans, and success rates.
network in the form of geo-distributed edge clouds, to afford
Index Terms—Auction mechanism, dependent tasks, edge wireless access service with lower communication delay for
cloud, Internet of Things (IoT) users, task offloading. users due to physical proximity to users [8], [9], [10], [11], [12].
Due to the high-quality user experience, the task offloading at
the edge clouds has become a hot research topic [13]. Numerous
works have been attracted to optimal task assignment strategies
for offloading dependent tasks to the edge clouds in terms of
makespan [8], [14], energy consumption [15], [16], as well as
Manuscript received 26 April 2022; revised 8 September 2022; accepted communication bandwidth [17].
26 October 2022. Date of publication 11 November 2022; date of current ver- Most of the existing solutions [15], [16], [17], [18], [19]
sion 7 March 2023. This work was supported in part by the National Natural
Science Foundation of China under Grant 62172445 and Grant 62072472; mainly focus on the dependent task assignment strategy for the
in part by the Hunan Provincial Natural Science Foundation of China single user’s application. In practice, the computing resources
under Grant 2022JJ50147; in part by the Scientific Research Project of of edge clouds are still relatively limited compared to the
Hunan Provincial Education Department of China under Grant 21A0568; in
part by the Shaanxi Key Laboratory for Network Computing and Security remote cloud, competition for the limited computing resources
Technology under Grant NCST2021YB-01; and in part by the 14th Five-Year- of the edge clouds is inevitable when the edge clouds need
Plan Project of Hunan Provincial Education Science under Grant ND228128. to serve multiple users at the same time [10]. Such resource
(Corresponding author: Yongmin Zhang.)
Jiagang Liu is with the School of Computer and Engineering, competition may seriously downgrade user experiences and
Hunan Institute of Technology, Hengyang 421002, China, also with the lead to the resource waste if computing resources are not
School of Computer Science and Engineering, Central South University,
Changsha 410083, China, and also with the Shaanxi Key Laboratory for
efficiently allocated. This consequently attracts a few works
Network Computing and Security Technology, Xi’an 710048, Shaanxi, China to investigate dependent task offloading for multiple users
(e-mail: [email protected]). in edge clouds [2], [20], [21]. However, most of their solu-
Yongmin Zhang is with the School of Computer Science and Engineering,
Central South University, Changsha 410083, China (e-mail: zhangyongmin@
tions make the offloading decision based on the priority of the
csu.edu.cn). offloaded tasks, without considering user preferences. Thus,
Ju Ren and Yaoxue Zhang are with the Department of Computer Science these solutions may reduce user experiences. Some works
and Technology, BNRist, Tsinghua University, Beijing 100084, China (e-mail:
[email protected]; [email protected]). considering user preferences allocate computing resources for
Digital Object Identifier 10.1109/JIOT.2022.3221431 tasks offloaded from multiple users in edge clouds by the
2327-4662 
c 2022 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See https://www.ieee.org/publications/rights/index.html for more information.
Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4908 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

auction theory [10], [22], [23], [24]. Unfortunately, most of theoretical analysis for this mechanism. Then, the simulation
these works make the offloading decision for independent evaluation and a conclusion are given in Sections VI and VII,
tasks rather than dependent tasks. Hence, these works are not respectively.
suitable for IoT applications composed of many dependent
tasks.
Our previous work [9] designed a reverse auction mech- II. R ELATED W ORK
anism to allocate computing resources for dependent tasks So far, increasing works are attracted to the topic of offload-
offloaded from multiple IoT applications based on the respec- ing dependent tasks from mobile devices and IoT devices to
tive benefits of IoT users and edge clouds, with the objective edge clouds. We briefly survey the related work in this section.
of minimizing the money costs of IoT users. It makes resource Most existing works focused on the dependent task offload-
allocation decisions in light of the tasks ready for execution ing for a single user by coordinating geo-distributed edge
in applications, neglecting the overall structure of the appli- devices [15], [16], [17], [18], [19], [26]. Kao et al. [15]
cation. Due to the lack of the complete information about proposed a task assignment algorithm with fully polynomial
an application, it always obtains myopic optimizations rather time for edge clouds to optimize the application execution
than the global ones [25]. This consequently motivates us to latency when satisfying the cost constraint. Lee et al. [18]
cope with competition among multiple users from the view- utilized the collaborative edge clouds deployed distributedly
point of the user preferences and whole information about each to minimize the application completion time. Liu et al. [19]
application. optimized the energy consumption and completion time of
In this article, we study the resource competition issues at vehicular applications by proposing a topology-aware dynamic
the edge clouds caused by the dependent task offloading of computation offloading strategy. Sundar and Liang [16] gave
IoT users from an economic point of view. We regard the the theoretical bounds of subdeadlines for task offloading
edge clouds and IoT users as sellers and buyers of computing when optimizing the application makespan. Naouri et al. [17]
resources, respectively. Then, we model the trade of comput- proposed a three-layer task offloading framework to mini-
ing resources as the auction-based game to maximize their mize the task communication costs under a greedy strategy.
valuation while satisfying tasks’ deadline constraints. To solve However, these works do not consider the case where multiple
this problem, we first design an auction mechanism based on users compete for the computing resources of the edge clouds.
the overall computing resources that the application requires. There are some existing dependent task offloading strategies
Due to the NP-hardness of this problem, we propose a greedy designed for multiple users by considering the dependent rela-
user selection strategy for participants in the auction. For tionships [1], [20], [21], [27], [28]. Yang et al. [27] proposed
each winner in the auction process, subsequently, we design a partitioning strategy for offloading applications with the
a heuristic-dependent task assignment strategy that can jointly sequential dependency to optimize the application makespan.
consider the task graph structure and the current status of the Bellal et al. [28] proposed an architecture, which can reuse
edge clouds. Particularly, the major contributions of this article the outputs of some tasks in applications to execute incom-
are summarized as follows. ing similar tasks, to optimize the makespans of applications.
1) We propose an auction-based task offloading framework, Zhao et al. [1] proposed a convex programming to reduce
in which IoT users’ tasks can be assigned according to the completion time of task offloading by considering the lim-
the task graph structure and the computing resources the ited service caching. Some works allocate computing resources
application requires, and formulate the trade of comput- for tasks offloaded from user devices by setting the task pri-
ing resources at edge clouds as a valuation maximization ority previously [2], [20], [21]. Sahni et al. [2] proposed a
problem, which can be proved to be NP-hard one. heuristic strategy to minimize the average completion time
2) We design a truthful auction mechanism, in which a of tasks by jointly considering the dependent task offload-
greedy algorithm is proposed to select the winning user ing and network flows. Their strategies assigned a priority
and determine the relevant payment based on a pay- based on the release time of tasks and computation load of
ment strategy. Both the task graph structure and the a subtask. Liao et al. [20] proposed a priority quantification
real-time workload of the edge clouds are considered method for applications to schedule the offloaded tasks, with
in the auction mechanism. the aim of improving the completion ratio of applications.
3) We theoretically prove that the designed auction mech- Liu et al. [21] proposed a heuristic strategy to optimize the
anism can ensure the truthfulness and individual ratio- application completion time based on the priority of applica-
nality of participants in the auction. tion arrivals. However, the abovementioned works research the
4) By conducting extensive simulations, we validate that dependent task offloading from the viewpoint of edge devices
the proposed task offloading strategy is superior to exist- without considering the user preference. Besides, their strate-
ing competition algorithms, in terms of total valuations, gies make assignment decision in the light of the status of
average makespans, and success rates. partial tasks in an application, so that these strategies may be
The remainder of this article is organized as follows. We myopic optimizations due to neglecting the overall structure
first briefly survey the related work in Section II. Section III of the application.
describes the system model and formulate the optimization Some works focus on the auction-based resource alloca-
problem. Section IV presents the proposed auction mechanism tion for the application offloading in MEC. Lu et al. [23]
and the relevant algorithm in detail, while Section V gives the researched the task offloading in the heterogeneous MEC

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4909

TABLE I
F REQUENTLY U SED S YMBOLS

Fig. 1. Edge clouds serving IoT users.

system based on the dual action model. Both Misra et al. [22]
and Gao et al. [10] applied the auction theory to allocate com-
puting resources for the application offloading in a three-layer
cloud structure. However, the above works do not consider the
applications comprised of many dependent tasks. Moreover,
most existing works studied auction-based resource allocation
strategies in the cloud computing. The work [29] proposed
an auction-based workflow scheduling for the cloud comput-
ing. In their auction mechanism, each task in an application
is regarded as an auctioneer who announces the request, and
the relevant bid is claimed by the cloud resource. The auction
occurs when finding the pairs of each task and the relevant
resource, and then they schedule each task in workflows with-
out considering the workflow structure. Gao et al. [30] studied
an auction-based graph job allocation in vehicular clouds to
maximize the utility-of-service of applications. Nevertheless,
Gao et al. [30] modeled the application as an undirected
weighted graph of tasks, of which the parallel processing
is fundamentally different from that of the DAG model.
Hence, this work is not suitable for the question we research.
Mashayekhy et al. [31] proposed a truthful auction mech-
anism to allocate heterogeneous cloud resources for online
users’ jobs. The authors modeled users’ jobs as the requests
for the number of different virtual resources without thinking coverage area that can afford wireless access services for IoT
about jobs’ structure. We get inspiration from it to achieve our users. To improve resource utilization and increase revenue,
previous work, in which we design a reverse auction mech- the edge clouds are disposed to sell their computing resources.
anism to allocate computing resources for dependent tasks On the other hand, IoT users want to utilize the edge clouds to
offloaded from IoT users. In the reverse auction mechanism, expedite the processing of the applications by the computing
each of the ready tasks is regarded as an auctioneer, while all offloading. Therefore, there exists a trade relationship between
edge server devices are considered as the bidders. Therefore, the edge clouds and the users. The former acts as sellers of
the overall structure of the application is not considered in the computing resources, and the latter acts as buyers. To facili-
previous work. tate understanding, frequently used symbols in this article are
Different from all existing works above, we design an auc- summarized in Table I.
tion mechanism based on the overall computing resources that
the application requires to cope with competition for the lim- A. System Model
ited computing resources of the edge clouds, with the objective
In the edge clouds, all edge devices are denoted as a set
of maximizing the total valuations. For each winning user in
M with |M| = M, and the index of edge devices are denoted
the auction, we assign all of its tasks to the edge clouds by
by m, (∀m ∈ {1, . . . , M}). For edge device m, the processing
considering both the task graph structure and the real-time
capability of its processing elements (PEs) is defined as ρm
workload of the edge clouds while satisfying the application
in terms of millions instructions per second. Due to limited
deadline.
computing resources, we assume that each edge device only
has one PE [16]. In the network composed by the edge clouds,
III. S YSTEM M ODEL AND P ROBLEM F ORMULATION the transmission rate between two edge devices is defined as
In typical MEC, there are many geo-distributed edge Bm,m (∀m, m ∈ {1, . . . , M}), where m and m denote two
devices [10], [16], [32]. The edge devices can communicate different edge devices, respectively, i.e., m = m .
with each other and form edge clouds to serve IoT users, Consider that the IoT users served by edge clouds can be
as shown in Fig. 1. Each edge device has an independent defined as a set U with |U | = N during a fixed time period

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4910 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

(0, ). Let n (∀n ∈ {1, . . . , N}) denote the nth user. The users’
applications comprise of the task sequence of dependent rela-
tionships, which can be denoted by the DAG model [8], [16].
We assume that one IoT user only offloads one application to
the edge clouds one time. Note that, for the case one user wants
to offload more than one application to the edge clouds, we
can treat the user as several virtual users, each of whom only
offloads one application one time. As a result, each IoT user
only has one application, so that the set U can also indicate
all IoT applications.1 Fig. 2. Execution of applications on edge devices.
The DAG related to application n can be expressed as
Gn (Tn , En ), where Tn and En are the set of tasks and directed
edges belonging to application n, respectively. Let In = |Tn | In general, the edge device executes tasks offloaded from
denote the total number of tasks in Tn . Then, a task in appli- IoT users following the first come first service manner (FCFS).
cation n can be indicated as tni (∀i ∈ {1, . . . , In }), where i is It means that, if the PE of edge device m is executing one task,
the index of tni in Tn . Task tni has a workload, which can be the other tasks that assigned to edge device m must wait in the
denoted as δni . Moreover, the directed edge set En = {enij } computing queue Qm of edge device m. Moreover, when task
represents the dependent relationships among tasks, where tni is completed on edge device m, the output data from it need
enij expresses the data dependency between tasks tni and tnj . to be transmitted to the edge devices to which the children of
Specifically, task tnj can only be executed after task tni is com- task tni are assigned.
pleted, and the output data from task tni needs to be transmitted Fig. 2 shows an example of the task offloading for IoT
to task tnj . Based on the dependent relationships, we call task user n with three edge devices. The DAG model for IoT user
tni the parent of task tnj , and call task tnj the child of task tni . n’s application is shown on the right side of this figure. This
Let pre(tni ) and suc(tni ) denote the set of the parents and chil- application contains six real tasks and two dummy tasks which
dren of task tni , respectively. For each data dependency enij , are denoted as the dotted red circles, i.e., t0 and t7 . The dotted
it is attached to a weight dnij which indicates the size of data arrows indicate the outgoing edges and incoming edges which
outputted from task tni to task tnj . Generally, for task tni , δni are, respectively, attached to t0 and t7 . The size of transfer data
and dnij can be known by profile analytics [33]. is denoted by the numbers attached to directed edges. When
If an application needs to be processed by edge clouds, some user n offloads its application for execution, the assignment
application data must be offloaded from the corresponding IoT of all tasks is shown on the left side of Fig. 2. Specifically,
user to the edge clouds. After all the tasks in an application user n first offloads the application data to the edge device 1n .
are completed by the edge clouds, the processing results will Built upon a task assignment decision, t1 and t2 are assigned
be sent back to the IoT user. To facilitated describe the DAG to the edge device 1n and edge device 3, respectively. The
model, we append two dummy tasks tnin and tnout to applica- two tasks can be directly executed on PEs after they receive
tion n as the entry and exit, respectively, i.e., Tn ∪ {tnin , tnout }. the incoming data from t0 (i.e., user n). Here, the tasks that
Note that, the workloads of two dummy tasks tnin and tnout are the PEs are executing are denoted as green circles. The other
zero. The indexes of tnin and tnout in Tn are denoted as 0 and tasks are assigned to the computing queues of edge devices
In +1, respectively. The outgoing edges from tnin and the incom- for waiting. The three edge devices can transfer the data to
ing edges to tnout are attached to the amount of transfer data, each other via the network link. Note that the edge device 2
respectively. Especially, the transfer data attached to the for- does not executes t4 before it receives the data outputted from
mer indicate the offloaded application data, of which the size t2 . Finally, the processing results will be sent back to t7 (i.e.,
is expressed as dn0i [tni ∈ suc(tnin )]. Those attached to the latter user n) after all tasks are completed.
describe the results, of which the size is denoted as dnj(In +1)
[tnj ∈ pre(tnout )], sent back to the IoT user. From the perspec-
tive of one user, its IoT device is also a special service device. B. Problem Formulation
Thus, user n can be regarded as the 0th edge device in M,
In the MEC system, each IoT user has the same network
which only handles tnin and tnout .
topology, as shown in Fig. 2. Thus, we can model the network
For the specified user n, the edge device covering it can
from one IoT user’s point of view for simplicity. More IoT
be denoted as mn for convenience. User n needs to send an
users connected to the network only increase the number
offloading request to edge device mn when user n wants to
of applications to be processed, which does not effect this
use the computing resources at mn . Let n = (rn , ln , bn , Gn )
model. Built upon this setting, we introduce an assignment
denote the offloading request released by user u, where rn and
strategy An = (an0 , . . . , an(In +1) ) for user n. Especially,
ln , respectively, indicate the release time of the request and
ani = (a0ni , . . . , aM
ni ) is the task assignment plan for task tni .
the deadline of the user, and bn expresses the reward that user
n is willing to pay for processing its application.
The assignment variable am ni (∀m ∈ {0 . . . , M}) is defined as
follows:

1 In this article, the terms, i.e., user n, nth user and application n, will be 
1, if task tni is assigned to edge device m
ni =
am
used interchangeable to indicate that one user offloads an application to edge (1)
clouds. 0, else
Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4911

where m = 0 indicates IoT user n. Since any task can only be receive the result data and sent back to the IoT user. Besides,
executed on one edge device, we have if task tni is not a dummy task, i.e., 0 < i < In + 1, the calcu-
lation of its completion time must take into account the queue

M
∀i ∈ {0, . . . , In + 1}. length of the waiting tasks on the target edge device, to which
ni = 1
am (2)
m=0 tni to be assigned, and the arrival of input data to tni . Hence,
in this case, F (ani ) can be calculated by
Note that, tnin and tnout must be located in the IoT user. Thus,  
we have max R(ani ), max F ( anj )
+C ( anj ,ani )
+T (ani )
. (9)
tnj ∈pre(tni )
a0n0 = 1, a0n(In +1) = 1. (3)
In (9), R(ani ) indicates the time when the edge device is ready
When edge device m executes task tni , the execution time to executetask tni under the assignment plan ani . Particularly,
T (ani ) of tni on the edge device can be denoted by R(ani ) = M m
 m=1 Rm ani , where Rm is the queue delay of edge
(ani ) 0, if i ∈ {0, In + 1} device m for task tni to be assigned.
T = M δni m (4)
m=1 ρm · ani , else. Moreover, we denote the makespan of application n as
span
Mn , which is determined by the maximum completion time
In addition to the execution time, there may exist a transfer among all tasks. Thus, we have
time between two tasks. Let C(ani ,anj ) denote the transfer time
between task tni and tnj . If tni and tnj are assigned to the same Mnspan = max F (ani ) − rn . (10)
tni ∈Tn
edge device, i.e., ani = anj , we have C(ani ,anj ) = 0. If tnj ∈
span
suc(tnin ) and tnj are assigned to edge device m, we need to As Mn must satisfy the deadline, which is a necessary con-
consider two cases. In one case, m = mn so that IoT user n dition of whether application n is completed successfully, we
must connect edge device m via the edge device mn . In the have the following constraint:
other, m = mn such that IoT user n can connect the edge
device mn directly. Hence, C(ani ,anj ) is calculated by Mnspan ≤ ln − rn . (11)
 dn0j M dn0j m   If assignment strategy An can assign all tasks of user n to the
Ben + m=1 Bmn ,m anj , if tnj ∈ suc tnin & m = mn
dn0j   (5) edge clouds and application n can be completed successfully,
Be ,
n
if tnj ∈ suc tnin & m = mn we deem that application n obtains the computing resources.
where Ben is the transmission rate between user n and the edge Thus, we define a decision function xn (An ) as follows:

device mn . Furthermore, if tni ∈ pre(tnout ) and tni is assigned 1, if user n gets the computing resources
to edge device m, we also need to consider two cases. In the xn (An ) = (12)
0, else.
first case, m = mn , so the edge device m connects IoT user n
via the edge device mn . In the second case, m = mn , and thus Besides, if application n is completed successfully, user n’s
the edge device m can connect IoT user n directly. Therefore, evaluation value for the offloading request corresponding to
C(ani ,anj ) is calculated by its application is defined as follows:
⎧d   
⎪ ni(In +1)
+ M
dni(In +1) m
ani , if tni ∈ pre tnout Vn (n ) = bn · xn (An ) (13)
⎪
⎪ B e m=1 B
⎨ n m,m n
& m = mn where bn expresses the valuation that user n gains for the
 out  (6)
⎪
⎪
dni(In +1)
, t ni ∈ pre tn execution of the application.
⎪
⎩ B e
All users in U want to gain computing resources to
n
& m = mn .
maximize their benefit in computation offloading, so that they
Finally, if tni and tnj are, respectively, assigned to edge devices will compete for computing resources. Therefore, the problem
m and m (m = m = mn ), the two edge devices can directly of offloading dependent tasks from all IoT users in U to the
connect to each other. Thus, C(ani ,anj ) is calculated by edge clouds aims at maximizing valuations while satisfying

M 
M
dnij the deadline constraints of each user. Thus, the optimization
m
· am
ni · anj , m = m = mn . (7) problem can be formulated by

Bm,m 

m=1 m =1
P1 : max bn · xn (An ) (14)
After edge device m completes task tni , the completion {xn (An )}
n∈U
time of tni can be known. Let F (ani ) denote the completion s.t. (2), (11)
time of task tni . If task tni is the dummy task, F (ani ) can be
n,i ∈ {0, 1} ∀n ∈ U
am ∀m ∈ M ∀i ∈ {1, . . . , In }
calculated by
 (15)
rn , if tni is tnin
xn (An ) ∈ {0, 1} ∀n ∈ U (16)
maxt ∈pre(t ) F (anj ) + C(anj ,ani ) + T (ani ) , if tni is tout .
nj ni n
where (2) indicates any task can only be executed on one
(8)
edge device, and (10) indicates the edge clouds must suc-
In the first condition of (8), the release time of the request cessfully process application n while satisfying its deadline
counts is the completion time of the task tnin . The second con- constraints, and (15) and (16) are the integrality requirements
dition of this equation indicates that the task tnout needs to for assignment variables and decision functions.

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4912 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

In addition to the valuations, the IoT users also intend problem:

to minimize the makespan of their applications. Thus, the  
makespan minimization problem for each IoT user can be min max F (ani ) − rn (20)
formulated as follows: am tni ∈Tn
n,i

1  s.t. (2), (11)

P2 : min  Mnspan · xn (An ) (17)
am
n,i
n∈U n (An )
x
n∈U n,i ∈ {0, 1}
am ∀n ∈ U ∀m ∈ M ∀i ∈ {1, . . . , In }.
s.t. (2), (11) (21)
n,i ∈ {0, 1} ∀n ∈ U
am ∀m ∈ M ∀i ∈ {1, . . . , In }. Visibly, P2 is at least as hard as (20). Moreover, (20) can
(18) be reduced to the makespan minimization problem in parallel
task scheduling [35], which is also NP-hard. In addition, An
By analyzing the above problems, we have the following is the argument of the decision function xn (An ) in P1, which
theorem. makes the solution to P1 more complicated. Considering the
Theorem 1: The problem P1 is NP-hard. real-time requirement, the edge clouds need to process offload-
Proof: In problem P1, the decision function xn (An ) cou- ing requests in time. Therefore, the solution to P1 requires an
ples assignment strategy An . Since An can only be 0 or 1 no efficiently offloading method with polynomial time rather than
matter what An is, we can denote xn (An ) as xn ∈ {0, 1}. Next, an optimal method with high time complexity. As a result, we
we assume that the number of edge devices is equal to one. propose two heuristic strategies to solute P1 and P2, respec-
In the case, all tasks of user n must be arranged in the com- tively. For P1, we propose an online auction strategy that
puting queue of the edge device according to the topological selects winners greedily. For P2, we propose a heuristic strat-
order of tasks, irrespective of assignment strategies designed egy for the assignment of dependent tasks to the edge clouds.
for user n. Suppose that the requests of all users in U have The solutions to P1 and P2 will be presented in the following
the same release time and deadline, which are, respectively, sections.
denoted as r̄ and l̄. Meanwhile, we permit that the dummy
task tn(In +1) can also be offloaded. As the tasks must wait in
IV. AUCTION M ECHANISM FOR D EPENDENT TASK
the computing queue for execution, the task located at the end
O FFLOADING
of the computing queue determines the makespan of user n.
span
Thus, n∈U Mn xn ≤ l̄ − r̄ holds. Accordingly, we gain a To handle the competition for computing resources, we
special case of P1 as follows: design an auction mechanism for dependent task offloading in
edge clouds. In this section, we first propose an auction frame-

P1 : max bn · xn work and then present how the auction mechanism works in
{xn } the framework.
n∈U
s.t. (2)

Mnspan · xn ≤ l̄ − r̄, xn ∈ {0, 1} ∀n ∈ U . A. Overview of Auction Framework
n∈U We consider that there is a coordinator in edge
(19) clouds [8], [15]. The coordinator can periodically collect the
latest status information about the deployed edge devices [10],
Visibly, P1 is at least as hard as P1 . The trivial 0–1 knap- including availabilities of PEs in individual edge devices, and
sack problem [34] is a well-known NP-hard problem, which average transmission rates between edge devices. After that,
is denoted as follows: the collected information will be publicized to edge devices,
n and the status data, related to task loads on edge devices, will
Q : max i=1 ωi zi be sent by the edge devices to IoT users. Build upon the coor-
{zi }
dinator, the auction framework for dependent task offloading

n
s.t. νi zi ≤ C, zi ∈ {0, 1} is shown in Fig. 3, where the coordinator acts as the auction-
i=1
eer. For any user n in the coverage area of each edge device,
it can register with the edge device mn covering it [8]. Once
where the number of items is n, each of which is indexed a user registers successfully, it can real-timely receive the sta-
by i. The weight and volume of item i are indicated by ωi tus data from the edge device mn . Otherwise, the user cannot
and νi , respectively. The capacity of the knapsack is indi- upload any task to the edge device.
cated by C. Now, we reduce the problem Q to P1 by setting Before each auction, each registered user makes an assign-
span
bn xn = ωi zi , Mn xn = νi zi , and l̄ − r̄ = C. If the instance ment mapping, recorded into the local IoT device, for its
of the problem P1 has a feasible input, the problem Q can application under a task assignment strategy according to the
be solved. Hence, we have Q ≤p P1 ≤p P1. This proves the real-time status data. Since the assignment mapping is made
theorem. from the user’s view, it can be called personal mapping.
Besides, xn (An ) can only be 0 or 1 in the problem P2. If Based on the personal mapping, each user will prepare the
there is only one user n that gains the computing resources, parameters for computing offloading [36], including the appli-
the problem P2 can be transformed into the following cation’s predicated makespan and the deadline. The user sends

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4913

where B̄ denotes the average transmission rate in the auction

framework and ρ̄ is the average processing capability of all
PEs in the edge clouds. To calculate PCP in terms of task
priority, we present the notion of marked task. A marked task
is the task that has been marked during the calculation of PCP.
For application n, initially, tnin and tnout are always regarded as
the marked tasks and the other tasks are not the marked tasks.
We denote by H(tni ) the special set of tni ’s children, in which
each of the tasks is not the marked task and all parents of each
task are marked tasks. Thus, we give the definition of critical
child as follows.
Definition 1 (Critical Child): For marked task tni , if its
child tnj has the highest priority in the set H(tni ), task tnj is
Fig. 3. Auction framework for dependent task offloading. the critical child.
We introduce an algorithm of calculating PCP paths [8] to
the reward that it expects to pay to the edge device mn for record PCPs of application n into the set S. Moreover, the num-
participation in the auction along with its offloading request. ber of PCPs in S is indicated as |S|. The algorithm traverses
During the auction, the auctioneer gathers task offloading each task from tnin to validate critical children and collect the
requests of participants from the edge clouds to determine the PCP path. Let Pnk indicate the kth PCP of application n, and
winners. Within the time periods the participants can tolerate, it is a task sequence {tni1 , . . . , tniq }, where iα (1 ≤ α ≤ q)
i.e., the user’s deadline, the auction will work continuously indicates that the αth task on Pnk corresponds to the iα th task
until no more participants appear. For a winner, the auctioneer in Tn , and q is the index of the last task on Pnk . More details
will assign all of its tasks to the edge clouds for processing of calculating PCPs can refer to [8].
according to the personal mapping. After an application is Subsequently, all PCPs in S need to be assigned to a per-
completed in the edge clouds, the auctioneer will send results sonal mapping in terms of processing capabilities and real-time
to the user and charge it based on a payment rule. The corre- workloads of all edge devices. The personal mapping is the
sponding register will be eliminated from the edge device mn data structure composed of linked lists, which is denoted as
and the allocated wireless channel will be freed. Ln = {Lm,p |m ∈ M, p ≥ 0}. Moreover, each of the linked
The remainder of this section introduces the task assignment lists is related to an edge device. Let Lm,p denote the linked
strategy and auction-based resource allocation mechanism. list related to edge device m, with p elements. Initially, Lm,p is
the empty list with a head node Hn , i.e., p = 0. Moreover, the
B. Personal Assignment Mapping for Dependent Tasks available time Rm of edge device m is recorded in Hn , which
can be calculated by
In edge clouds, edge devices cooperate with each other via
the wireless communication. If two tasks attached to a depen- Rm = max F (an i ) (23)
dent relationship are assigned to different edge devices, the tn i ∈Q(m)
output data from a completed task in one edge device need to where Q(m) denotes the computing queue of edge device m
be transmitted to another edge device via the wireless commu- and tn i is a waiting task in Q(m). Note that, the waiting tasks
nication. The larger the size of transfer data between the two in Q(m) may belong to different applications.
dependent tasks, the longer the data transfer time between two An element of Lm,p is denoted as a tuple, i.e.,
edge devices. To reduce the transfer time, therefore, we expect pst pct
(Sni (m, ψ), Fni (m, ψ)). Particularly,
pst
Sni (m, ψ) and
to assign a task sequence, in which the tasks are attached to pct
Fni (m, ψ) are the predicted start time and predicted
a directed path with bigger transfer data in the DAG model,
completion time of tni in the ψth element of Lm,p , respec-
to the same device as much as possible. pst
tively. Moreover, Sni (m, ψ) (∀ψ, 1 ≤ ψ ≤ p) can be
The partial critical path (PCP) [37] can partition the DAG
calculated by
into several task sequences. When a PCP is assigned to an ⎧  
edge device, the transfer time between tasks on the PCP is ⎨ max RL ,
m rn + C(an0 ,anj ) , if tnj ∈ suc tnin
equal to zero. The PCP can be determined by the task pri-   δnj
⎩ max RL , maxt ∈pre(t ) Spst m , ψ  + +
dnm m
, else
ority [8]. There are many methods for the acquisition of the m nj ni nj ρm Bm ,m

task priority. The bottom level (b-level) is a classic attribute (24)

for task priority [38]. For task tni , its b-level presents a criti-
where ψ  is the index of tnj in another Lm ,p . If Lm,p and Lm ,p
cal path from tnout to tni , which is the maximum length of all
are the same linked list, i.e., m = m , (dnm m /Bm ,m ) = 0. RL
directed edges and tasks between tnout and tni . According to the m
is the ready time of edge device m for the execution of tni ,
b-level, the task priority for tni (∀i, 0 ≤ i ≤ In+1 ), denoted by
according to the ranking of tni in Lm,p . Particularly, RL m can
pri(tni ), is defined as follows:
⎧ be calculated by
⎨ 0, out 
if tni istn  pst δ 
pri(tni ) = maxtnj ∈suc(tni ) , pri tnj + dnij /B̄ (22) maxζ ∈Lm,ψ−1 (tni ) Sni (m, ζ ) + ρnim , if p = 0
⎩ (25)
+δni /ρ̄, else Rm , else

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4914 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

where p = 0 indicates that Lm,p is not the empty list, p = 0 Algorithm 1 PersonalPCP(S)
indicates that Lm,p only has a head node Hm , Lm,ψ−1 (tni ) Input: The set S that contains PCPs of application n; Rm for
denotes the sublist of elements in front of tni in Lm,p , ψ − 1 all m ∈ M;
is the length of Lm,ψ−1 (tni ), and i is the index of the task tni Output: The assignment mapping of application n;
recorded in the element ζ , respectively. In other words, RL m is 1: for each k ∈ {1, . . . , |S|} do
determined by the last task in Lm,ψ−1 (tni ) when Lm,p is not 2: m∗ ← ∅, f ← ∞, P ← ∅;
the empty list. Accordingly, the predicted completion time of 3: for each m ∈ M do
tni in Lm,p can be denoted as follows: 4: L ← ∅;
pct pst 5: for each tni on Pnk do
Fni (m, ψ) = Sni (m, ψ) + δni /ρm . (26) 6:
pst
Traverse Lm,p and calculate Sni (m, ψ) and
pct
Additionally, the latest completion time of each task is an Fni (m, ψ) by Eqs. (28) and (29);
pst pct
important criterion for the assignment strategy. It provides the 7: Insert the element (Sni (m, ψ), Fni (m, ψ)) into the
time condition for the completion of each task without missing tail of L ;
the user’s deadline [38]. To calculate it, we can consider the 8: end for
pct
average transmission rate between edge devices and assume 9: if f > max Fni (m, ψ) then
L
that all tasks are assigned to different edge devices with 10: f ← max Fni (m, ψ); P ← L ; m∗ ← m;
pct
the biggest processing capability. Thus, tni ’s latest completion L
time, denoted by Fni lct , can be calculated by 11: end if
   12: end for
ln − dni(In +1) /Ben , if tni ∈ pre tnout 13: Insert P into Lm∗ ,p based on target positions;
lct − δ /ρ max − d /B̄es ,
mintnj ∈suc(tni ) Fnj else 14: end for
nj nij
(27)
lct = max lct lct
where ρ maxindicates the biggest processing capability in the where Fni ∗ tni ∈Tn Fni . In other words, Fni∗ is the
edge clouds, and B̄es denotes the average transmission rate maximum latest completion time of tasks in application n.
between edge devices. For tnin and tnout , we do not need to Note that, in (28)–(30), ψ = 1 indicates that the position
consider the latest completion time since they must locate in following the head node of Lm,p is the target position, and ψ =
the IoT user. p+1 represents that the tail of Lm,p is the target position. Based
The assignments of PCPs are based on the heuristic strategy on the rule above, we propose a function PersonalPCP for the
with the object of minimizing the makespan of the correspond- assignments of PCPs, which can be given by Algorithm 1.
ing application while satisfying the deadline constraints. We Leveraging Algorithm 1, we can obtain a personal map-
introduce the notion of target position for the assignment of ping for user n. Build upon the personal mapping, user n can
a PCP to the linked list as follows. predict the processing time σn of its application, which can be
Definition 2 (Target Position): It is the first position that one calculated by
traverses Lm,p from the head to find out, in order to place the pst  
σn = max Fni (m, p) − min Sni m , 1
pct
element recording tni . The position must satisfy the following tni ∈Tn tni ∈Tn
condition. + C(an0 ,ani ) + C(ani ,an(In +1) ) (31)
1) The predicted start time of tni in the ψth element of
Sni (m , 1)
pct pst
Lm,p satisfies where Fni (m, p) and are the predicted completion
 time and start time calculated by the personal mapping, and
pst
Sni (m, ψ) ≥
τ, if ψ = 1
(28) ∀m, m ∈ {1, . . . , M}. Note that, C(an0 ,ani ) in (31) is the trans-
pst
Fnj (m, ψ − 1), else fer time between user n’s IoT device and edge device m on
 lct
which Sni (m , 1) of tni is minimum for all tni ∈ Tn . Similar
pst
pst δni Fni , if ψ = p + 1
Sni (m, ψ) + ≤
ρm
pst
min Snj (m, ψ + 1), Fni
lct , else interpretation can apply for C(ani ,an(In +1) ) in (31).
(29) Subsequently, user n can send the offloading request with
parameter σn to edge device mn for participation in the auction.
j
where j and are the indexes of tnj and tnj in Tn , and Meanwhile, the reward bn that user n is willing to pay is
τ is the current system time. Moreover, tnj and tnj are regarded as the submitted bid for participation in the auction.
recorded in the ψ − 1th and ψ + 1th elements, respec- Thus, the offloading request of user n can be expressed as
tively. The first condition of (28) indicates that tni is n = (rn , ln , bn , Gn , σn ).
inserted into the first element of Lm,p . The first con-
dition of (29) denotes that tni is appended to the end C. Auction Mechanism Design
element of Lm,p . To maximize valuations, the auctioneer selects the winners
pst
2) If Sni (m, ψ) fails to satisfy (29), it must satisfy from users’ requests by an auction mechanism, and assigns the

δni lct ,
Fni if ψ = p + 1 winners’ tasks to the edge clouds with deadline constraints.
pst ∗
Sni (m, ψ) + ≤ pst We define an auction mechanism as a tuple (X, Y). Here,
ρm Snj (m, ψ + 1), else
X = {x1 (A1 ), . . . , xN (AN )} is the set of binary decision func-
(30) tions for all users. Specifically, xn (An ) = 1 means that user

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4915

n can successfully obtain relevant computing resources under higher bid or requires a shorter predicted processing time. In
assignment strategy An in the auction, and its request can be this work, we assume that any user does not require a shorter
selected as the winner. Y = {Y1 , . . . , YN } is the set of pay- predicted processing time than the predicted processing time
ment rules which determine the rewards that users should pay determined by its personal mapping. This is because the user’s
for obtaining the computing resources. In this auction mecha- application may not be successfully processed under requiring
nism, user n can be characterized by bn and σn in offloading a shorter predicted processing time. Built upon the description
request n . For simplicity, we use πn = (bn , σn ) to describe above, we give the definition of monotonicity for the selection
the request of user n for auction. However, users are selfish, strategy as follows.
and they expect to maximize their own utilities. They may Definition 5 (Monotonicity) [31]: If user n that claims
handle the mechanism by claiming tricky requests different request π̂n can be selected as the winner, the user that claims
from their real requests. For example, user n can increase the request π̂n is also the winner when π̂n π̂n .
probability of winning by submitting a higher spurious bid. Based on a monotonic selection strategy, any user n is
The trick handling may result in the low efficiency of resource selected as the winner when claiming request π̂n , such that
allocation, and go so far as to reduce the utility of the edge user n is still a winner if it claims a more dominant request,
clouds [31]. Let π̂n = (b̂n , σ̂n ) express the requests claimed e.g., a higher bid.
by user n, while πn is the real request of user n. Besides from the monotonic selection strategy, we need to
In each auction, the auctioneer will determine a request π̂n define a payment rule based on the critical payment which can
from participants, and then assign all tasks of user n to the ensure that the reward that user n pays must be irrelevant to
edge clouds based on user n’s personal mapping made by An . its request [41] as follows.
It means that user n can successfully obtain the computing Definition 6 (Critical Payment): Under the monotonic
resources, and then π̂n is the winning request, i.e., xn (An ) = 1. selection strategy, there exists a unique critical payment value
Accordingly, the valuation of user n is redescribed as Vn (π̂ ) = b∗n for each request πn . User n can become a winner if it claims
bn . If user n is not selected by the auctioneer, Vn (π̂ ) = 0. request π̂n ∀π̂i (b∗n , σn ), otherwise it will be a loser.
Let π̂ = (π̂1 , . . . , π̂N ) indicate the requests of all users. According to the critical payment, the reward that user n
Then, all requests except user n’s request can be denoted needs to pay is b∗n , if it becomes a winner when claiming
π̂ −n , i.e., π̂ −n = (π̂1 , . . . , π̂n−1 , π̂n+1 , . . . , π̂N ). We define request π̂n . Otherwise, the reward that user n pays is zero
Y(π̂n , π̂ −n ) as the reward that user n needs to pay based on since it is a loser in the auction. The critical payment is the
the payment rule in the auction. The utility of user n can minimum bid that user n must claim to obtain the computing
be calculated by Un (π̂n , π̂ −n ) = Vn (π̂n ) − Y(π̂n , π̂ −n ). We resources.
first introduce a feature related the truthful auction mechanism,
which is named individual rationality, as follows.
Definition 3 (Individual Rationality) [31]: In an auction, D. Auction-Based Computing Resource Allocation
each user n that claims the real request πn can always obtain To implement the dependent task assignment, we expand the
a nonnegative utility, i.e., Un (πn , π̂ −n ) ≥ 0, when the other idea of the work [31] to design a greedy computing resource
users claim the requests π̂ −n . allocation strategy, named AU-PCP, for participants in the
In an auction with individual rationality, the truthful users auction. In AU-PCP, the winners can be determined by a truth-
that claim their real requests will never obtain the negative ful user selection strategy. Then, the winners’ tasks can be
utility. Nevertheless, the individual rationality fails to motivate assigned to the edge devices according to the previous per-
users to truthfully claim their requests. Thus, we introduce sonal mapping. Moreover, the rewards that the winners should
another feature, named truthfulness, as follows. pay are confirmed by the critical payment.
Definition 4 (Truthfulness) [31]: For the requests π̂ −n The AU-PCP strategy is invoked on receipt of two events.
claimed by the other users, the utility that user n claim- One is the arrival of any user’s offloading request. Another
ing the real request πn obtains is not lower than one that event occurs, if any application is completed by the edge
user n obtains when claiming any other request π̂n , i.e., clouds or the computing queue of any edge device is empty,
Un (πn , π̂ −n ) ≥ Un (π̂n , π̂ −n ). when any edge device completes a task. AU-PCP will trig-
The users must truthfully claim their real requests, so that ger the auction process when either of the two events occurs.
they can obtain larger utility in an auction mechanism with Before each auction starts, IoT users claim the request π̂n =
truthfulness, without respect to the requests claimed by other (b̂n , σ̂n ) by Algorithm 2. For IoT user n, Algorithm 2 will be
users. The individual rationality and truthfulness ensure that invoked several times when σn can satisfy user n’s the dead-
users are willing to claim their real requests. In order to imple- line, until user n becomes the winner or its deadline is lost.
ment the two features, we must design a selection strategy with Line 3 in Algorithm 2 collects the set of PCPs for applica-
monotonicity to determine winning users for the auction mech- tion n, only when user n takes part in the auction for the first
anism. Meanwhile, the reward each winner pays is determined time. Moreover, user n claims the auction request π̂n when the
by the critical payment [39], [40]. predicted processing time σn obtained by it satisfies the dead-
In the auction mechanism, we introduce a preference rela- line (line 7). Otherwise, user n gives up on the computing
tionship for the set of users’ requests, which is defined as . offloading.
Particularly, if b̂n ≥ b̂n or σ̂n ≤ σ̂n , we have π̂n ≥ π̂n . It Algorithm 3 is the core of the AU-PCP strategy. When the
means that π̂n is more dominant than π̂n if user n claims a algorithm is invoked, it will collect the request set Qτ of users

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4916 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

Algorithm 2 Generating the Request of User n for Auction Algorithm 4 WinningAllocation(τ , Qτ )

Input: Rm for all m ∈ M; A set S containing PCPs; Output: The decision xn∗ (An∗ ) at time τ ;
Output: The request π̂n of user n; 1: xn∗ (An∗ ) ← ∅;
1: π̂n ← ∅, τ ←the current system time; 2: Calculate μn for all π̂n ∈ Qτ according to Eq. (32);
2: if S is null then 3: Sort Qτ by a non-descending order of μn ;
3: Collect all PCPs for application n and record them in 4: Find out the maximal π̂n in Qτ and obtain Ln =
S; {Lm,p |m ∈ M};
4: end if 5: for each m ∈ M do
5: PersonalPCP(S); 6: for each ψ ∈ {1, . . . , p} do
pst pct
6: Calculate σn by Eq. (31); 7: Assign (Sni (m, ψ), Fni (m, ψ)) in Lm,p to the cor-
7: if τ + σn ≤ ln then responding position of the computing queue in edge
8: π̂n ← (σn , b̂n ); device m;
9: return (π̂n ); 8: end for
10: else 9: end for
11: User n drops out of this auction and gives up on the 10: Extract An and set xn (An ) to 1;
computing offloading; 11: xn∗ (An∗ ) ← xn (An );
12: end if 12: return xn∗ (An∗ );

Algorithm 3 AU-PCP (Receipt of Two Events) Algorithm 5 WinningReward(τ , Qτ , X, Y)

Input: The set Qτ of requests for participation in this auction; Output: Y = (Y1 , . . . , YN );
Output: (X, Y); 1: Q̄τ ← Qτ \ π̂n∗ ;
1: τ ←the current system time; 2: g ← ∅;
2: if Qτ is null then 3: if Q̄τ is not null then
3: return; 4: xn̄ (An̄ ) ←WinningAllocation(τ , Q̄τ );
4: end if 5: Extract n̄ from xn̄ (An̄ ), and then g ← n̄;
5: xn∗ (An∗ ) ←WinningAllocation(τ ,Qτ ); 6: Yn∗ ← μg · σ̂n∗ ;
6: Y ← Y ∪ b(π̂n∗ , xn∗ (An∗ )), X ← X ∪ xn∗ (An∗ ); 7: else
7: Y ←WinningReward(τ , Qτ , X, Y); 8: Yn∗ ← b̂n∗ ;
8: return (X, Y) 9: end if
10: Y ← Y ∪ Yn∗ ;
11: return Y;
that participate in the current auction process. If Qτ is not null,
the function WinningAllocation is called in terms of τ and Qτ ,
and then a winning decision xn∗ (An∗ ) is returned. The request service per unit time. Thus, our user selection strategy deter-
π̂n∗ with respect to xn∗ (An∗ ) is the winning declaration in the mines the winning user based on the nonincreasing order of
current auction process, and all tasks of the relevant user n∗ their valuation weight, then allocates the computing resources
have been assigned to the edge clouds. This algorithm extracts to the winner. For the winner, the allocation of computing
the initial reward b(π̂n∗ , xn∗ (An∗ )) from xn∗ (An∗ ) (line 6). Here, resources is based on its personal mapping.
b(π̂n∗ , xn∗ (An∗ )) indicates the bid in the request π̂n∗ that the The function WinningAllocation shown in Algorithm 4 is
user n∗ claims at time τ . In other words, the reward is set to allocate the computing resources for the winner in the cur-
to the initial bid b̂n∗ . Then, this algorithm updates the entire rent auction process. This algorithm finds out the maximal
reward set Y and entire decision set X by b(π̂n∗ , xn∗ (An∗ )) and π̂n in the set Qτ sorted by the nonincreasing order of μn ,
xn∗ (An∗ ), respectively (line 6). Afterward, the set Y will be and then obtains the personal mapping Ln = {Lm,p |m ∈ M}
updated again by the function WinningReward (line 7) which (line 4). Whereafter, this algorithm traverses each linked list
determines the winner’s payments at time τ . Lm,p related to edge devices, and assigns the task denoted by
To determine the winner from participants in the auction, pst pct
(Sni (m, ψ), Fni (m, ψ)) in Lm,p to the corresponding position
we introduce a metric named valuation weight for each user n, of the computing queue in edge device m. Finally, the decision
which is defined as follows: xn∗ (An∗ ) is returned (lines 10–12).
b̂n The function WinningReward shown in Algorithm 5 can
μn = . (32) determine the critical payment that the winning user n∗
σn
should pay when it obtains the computing resources at time
The bid claimed by user n can be regarded as an evaluation τ . The algorithm first finds out the set Q̄τ that does not
value for requesting the amount of service time allocated by contain the winning request π̂n∗ . Subsequently, the function
the edge clouds under the personal mapping. Therefore, μn WinningAllocation is called in terms of Q̄τ if Q̄τ is not the
describes how much user n evaluates the estimated valuation empty set. Then, it returns the decision xn̄ (An̄ ) with respect to
per unit time. This is because the edge clouds prefer the users the user n̄ who is the winner in the absence of user n∗ , but
that are willing to pay more rewards for requesting computing who is the loser in the presence of user n∗ (line 4). Based on

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4917

decision xn̄ (An̄ ), the user n̄ is found out and recorded in g. a lower bid which is less than the minimum bid Yn∗ . This
Finally, the reward that user n∗ needs to pay is set to μg · σ̂n unique bid is the critical payment that user n∗ should claim
(line 6). If Q̄τ is the empty set, the reward of user n∗ is still to obtain the computing resources. In line 8 of Algorithm 5,
equal to its bid b̂n∗ (line 8). moreover, the reward of user n∗ is still equal to its bid b̂n∗ .
This means that Qτ only contents one request, i.e., π̂n∗ , so
that Q̄τ is the empty set. In the case, user n∗ ’s bid b̂n∗ is
V. T HEORETICAL A NALYSIS also the minimum bid that user n∗ can claim to obtain the
In this section, we theoretical analyze the AU-PCP algo- computing resources. As a result, the winning user’s payment
rithm in terms of individual rationality, truthfulness, and time that the function WinningReward determines is the critical
complexity. payment.
Recall that, the individual rationality requires that the user After gaining the two lemmas about the winner selection
claiming the real request must obtain the nonnegative utility. strategy, we can give the theorem that indicates our auction
Then, we first give Theorem 2. mechanism is truthful.
Theorem 2: The auction mechanism that the AU-PCP algo- Theorem 3: The auction mechanism that the AU-PCP algo-
rithm implements are individually rational. rithm implements are truthful.
Proof: User n’s utility is equal to Un (π̂n , π̂ −n ) = Proof: According to Lemmas 1 and 2, the auction mecha-
Vn (π̂n ) − Y(π̂n , π̂ −n ). For a winning user n∗ , its utility must nism the AU-PCP algorithm performs can satisfy monotonicity
be nonnegative if it claims the real request, i.e., b̂n∗ = bn∗ . and the payment is determined by the critical payment. So, this
In line 6 of Algorithm 5, the reward that winning user n∗ theorem holds.
pays is set to μg · σ̂n∗ , in which user g is the user who Besides, since offloading requests of users need to be
becomes the winner if user n∗ does not participate. The real-timely processed in the system, we analyze the time com-
emergence of user g is behind user n∗ in the nonincreas- plexity of the proposed auction mechanism to present that our
ing order of the welfare weigh so that we have μg ≤ μn∗ . auction mechanism works in polynomial time.
Therefore, bn∗ = b̂n∗ = μn∗ · σ̂n∗ ≥ μg · σ̂n∗ = Yn∗ such that Theorem 4: The auction mechanism that the AU-PCP algo-
Algorithm 5 always outputs the reward Yn∗ ≤ bn∗ for win- rithm implements is polynomial.
ning user n∗ . Accordingly, user n∗ ’s utility can be calculated Proof: The proposed auction mechanism is to determine
by Vn∗ (π̂n∗ ) − Yn∗ = bn∗ − Yn∗ ≥ 0, that is, user n∗ can not a winning request of users from participants in each auction
obtain the negative utility. Moreover, if the set Q̄τ that does process. For each user n, its personal mapping may be made
not contain the winning request π̂n∗ is null, Yn∗ is set to b̄n∗ several times within the time periods it can tolerate. However,
(line 8 of Algorithm 5). Thus, the corresponding utility is still the time that each user consumes for generating personal map-
nonnegative. Besides from the winning users, if the user that ping has nothing to do with the auction process. Therefore,
claims the real request becomes the loser, the utility that it the time complexity of each auction process is only related
obtains is zero. Hence, the theorem is proved. to Algorithm 3. Moreover, the complexity of this algorithm
Next, we will prove the proposed auction mechanism is is mainly determined by the function WinningAllocation and
truthful. In doing so, our auction mechanism must satisfy WinningReward.
Definitions 5 and 6 [39], [40]. We first give two lemmas about In the function WinngAllocation, i.e., Algorithm 4, calcu-
the winner selection strategy as follows. lating μn for all π̂ needs at most time O(N). Sorting the set Q
Lemma 1: The function WinningAllocation is monotonic. in line 3 needs time O(N log N). The first request in Q sorted
Proof: If user n claiming request π̂n becomes a winner, by a nondescending order of μn is the maximal π̂, so that
it will be also a winner when it claims a more dominated the time complexity of line 4 is a constant time. Lines 5–9
request π̂n according to Definition 5. In Algorithm 4, if user of this algorithm is to assign tasks recorded in all linked lists
n claims b̂n ≥ b̂n , its request π̂n will be also selected as a to edge clouds. Since there are almost In tasks in each linked
winner. Moreover, the computing resources will be allocated lists, the time complexity is equal to O(M · In ). Therefore,
to user n when π̂n becomes a winning declaration. Therefore, Algorithm 4 needs to consume time O(N + N log N + M · In ).
Lemma 1 is proved. Besides, the function WinningReward, i.e., Algorithm 5, needs
Lemma 2: The winning user’s payment that the function to call the function WinngAllocation again, which requires
WinningReward determines is the critical payment. time O(N + N log N + M · In ). As a result, the proposed auc-
Proof: In line 10 of Algorithm 5, the reward that user tion mechanism needs time O(N + N log N + M · In ). It is the
n∗ needs to pay is equal to Yn∗ = μg · σ̂n∗ . Here, g indicates polynomial time.
the index of user g. User g emerges behind user n∗ according
to the nonincreasing order of the welfare weigh. In the case,
user g will become the winner if user n∗ does not participate, VI. P ERFORMANCE E VALUATION
but user g is a loser in practice. Assume that user n∗ claims In this section, we conduct the AU-PCP algorithm in the
a lower bid b̂n∗ < Yn∗ . We have μn∗ = b̂n∗ /σ̂n∗ < Yn∗ /σ̂n∗ . simulation platform built by combining EdgeCloudSim [42]
Now, we substitute Yn∗ = μg · σ̂n∗ into it, such that we have and ElasticSim [43]. Meanwhile, we compare AU-PCP with
μn∗ < μg · σ̂n∗ /σ̂n∗ . Hence, μn∗ < μg holds. This means that several competitive algorithms for performance evaluation.
user n∗ will emerge behind user g who is a loser in prac- On account of the lack of works focusing on a similar topic,
tice. Consequently, user n∗ will become a loser if it claims we implement two competitive algorithms, called Nearest and

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4918 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

TABLE II
PARAMETERS OF E DGE D EVICES

TABLE III
PARAMETERS OF A PPLICATIONS Fig. 4. Valuation comparisons.

original runtime recorded in the DAX is not changed.2 Also,

we define a base communication time ct, which is calculated
by the element size recorded in the DAX. Particularly, ct is
set to 10−3 or 10−2 , respectively, if size/B̄ exceeds the range
of [10−3 , 10−2 ]. Otherwise, ct = size/B̄. Then, we use ct · B̄
to set the size of transfer data between dependent tasks, and
the amount of transfer data attached to the dummy tasks is
also set to ct · B̄.
Selfish [10], [44], by heuristically selecting winning users. Yet,
In our experiments, we randomly select 300 applications
the two algorithms still are based on the personal mapping
from the four types of workflows, based on the Poisson dis-
generated by Algorithm 1, and their task assignment strategies
tribution with λ, to simulate offloading requests released by
still assign the winning personal mapping to the edge clouds.
users. Also, we let the offloading requests randomly emerge
Particularly, Nearest always selects the request with the small-
at the service areas of four edge devices under a uniform dis-
est predicted processing time, and Selfish expects to select the
tribution. For the generation of user bids, we introduce the
request with the highest bid. Besides from Nearest and Selfish,
weight ecn of execution cost for each application n. It is cal-
we also compare AU-PCP to three state-of-the-art dependent
culated by ecn = MaxCost · twn /MinCap, where MaxCost is
task assignment algorithms, i.e., CEFO [45], Zhang’s PCP [8],
the unit cost of Edge device 1, and twn indicates the sum
and ITAGS [16], for edge clouds to evaluate the performance
of workloads in application n, and MinCap is the processing
of processing multiple applications. Specifically, CEFO focus
capability of Edge device 4. Next, user n’s bid is denoted by
on optimizing makespans of multiple users in edge clouds.
generating a random number between ecn and 5 · ecn under a
Zhang’s PCP is an offloading strategy based on the PCP
uniform distribution. Moreover, we define a basic makespan
theory, which is similar to my personal mapping. ITAGS is
Spn for each application n. To calculate Spn , we assign each
a list-based offloading strategy that can collaborate hetero-
task in application n to a distinct edge device, which has the
geneous computing resources. Moreover, Zhang’s PCP and
average processing capabilities in the edge clouds, when all
ITAGS are to minimize the makespan of the applications,
transfer data in application n are regarded as zero. Thus, we
without considering competition among multiple applications.
set the deadline of application n to ln = rn + df · Spn , where
df is the deadline factor, shown in Table III, for each type of
workflows. To relieve randomness, all algorithms are lunched
A. Simulation Setup for 30 times, in turn, and then the average value is calculated
In the simulation of our auction mechanism, the edge clouds for painting.
comprise four edge devices. Their processing capability and
unit cost are listed in Table II. Moreover, the threshold of B. Performance Evaluation for Auction Mechanism
registration in each edge device is set to 30. Similar to [16],
In this group experiment, we evaluate the proposed auction
The transmission rate Bm,m (m = m ) between edge devices
mechanism in terms of the total valuation by comparing it with
is set to 440 Mb/s. Moreover, Ben between each user n in the
the other five algorithms.
coverage area of an edge device and the relevant edge device
Fig. 4 shows that the valuation of Nearest is slightly higher
is set to 103 Mb/s. The average transmission rate B̄ in the
than AU-PCP when λ ≤ 5. Nevertheless, AU-PCP can obtain
auction framework is calculated by (440 × 6 + 103 )/7, i.e.,
the highest valuation among the six algorithms as the increase
520 Mb/s.
of λ. Moreover, it can be seen from the figure that the valua-
We take four types of realistic scientific workflows [46],
tion obtained by AU-PCP is much larger than CEFO, Zhang’s
shown in Table III, as the DAG structures of IoT applica-
PCP, and ITAGS. Since the three state-of-the-art algorithms
tions [8]. The workload of a task in an application is denoted
handle competition for the computing resources of the edge
by the element runtime recorded in the DAX. Specifically,
runtime is set to 100 or 500, respectively, if the original 2 EdgeCloudSim requires that the execution time of any task is bigger than
runtime exceeds the range of [100, 500]. Otherwise, the 0.01 s.

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4919

(a) (b)
Fig. 5. Individual rationality.
Fig. 7. Makespan Comparisons. (a) Makespans of AU-PCP, selfish, and
nearest. (b) Makespans of CEFO, Zhang’s PCP, and ITAGS.

Fig. 6. Truthfulness.

devices based on the priority of application arrivals rather than

user preferences, they achieve poor valuation when processing
multiple applications. The results verify that the auction-based Fig. 8. Success rate comparisons.
computing resource allocation can maximize the valuations of
users as much as possible.
To verify the individual rationality and truthfulness of AU- is only slightly higher than Nearest. For Nearest, it always
PCP, we design two experiments for AU-PCP separately by selects the request with the smallest predicted processing time,
setting λ = 20. Based on the experimental methodology of so it can achieve the lowest makespan among six algorithms.
the work [10], we first let AU-PCP process 500 applications Accordingly, Nearest can also achieve the highest success rate
20 times and then output payments and valuations of success- among six algorithms, as shown in Fig. 8. However, the val-
ful users, i.e., winning users. Fig. 5 reveals that the payments uation achieved by Nearest is lower than that of AU-PCP,
of all successful users are less than their valuations, which as shown in Fig. 4, when they process a larger number of
coincides with Theorem 2. To eliminate the randomness of IoT users. Additionally, it can be seen from Fig. 8 that AU-
evaluating truthfulness, we only let AU-PCP process 50 appli- PCP achieves the second-highest success rate among the six
cations with the same type and set λ to 20. Particularly, we algorithms. This can be interpreted that AU-PCP effectively
evaluate the truthfulness of AU-PCP based on the workflow estimates whether the makespan of an application is less than
type “Inspiral.” In this experiment, we randomly designate a its deadline according to the real-time task loads in the edge
user request and let its real valuation be equal to its originally clouds and the overall structure of an application. To sum up,
claimed bid. Moreover, the designated user claims a tricky bid the results verify the user selection strategy based on the val-
different from its valuation. We can observe in Fig. 6 that the uation weight is more suitable for the auction mechanism that
designated user’s payment is zero when the relevant bid is maximizes the valuation. Again, AU-PCP can effectively cope
lower than a given value. This means that this user is a loser with competition among multiple users from the viewpoint of
based on the bid that it claims in the auction process, so that user preferences and improve the performance of dependent
the designated user’s utility is also zero, as shown in this fig- task offloading for IoT Users.
ure. Again, the designated user’s payment is always equal to
a fixed value when the bid claimed by this user is higher than VII. C ONCLUSION AND F UTURE W ORK
the given value. Accordingly, this user’s utility also remains a
This article studied the problem of dependent task offload-
fixed value. The result verifies the correctness of Theorem 3.
ing from multiple IoT users to MEC, where IoT users compete
for the computing resources of MEC. We have proposed an
C. Performance Evaluation for Processing Multiple auction framework of dependent task offloading for multiple
Applications users in MEC, as well as a greedy winner selection strat-
In this group experiment, we evaluate the performance of all egy for participants, based on the truthful auction mechanism.
algorithms in terms of the average makespan of all applications For each winner, a heuristic strategy has been designed to
and their success rates. Here, the success rate is the ratio of assign the winner’s all tasks according to the PCPs of the
the number of successfully completed applications to the total application, the user’s deadline, and the current status of
number of applications. A successfully completed application MEC. Moreover, theoretical analysis has also been given to
means that the application is completed before its deadline. prove that the proposed auction mechanism can ensure the
Fig. 7 shows that the makespans that CEFO, Zhang’s PCP, truthfulness and individual rationality of participants in the
and ITAGS achieve are much higher than AU-PCP, Nearest, auction, and the proposed algorithm is polynomial. Extensive
and Selfish. Moreover, the makespan achieved by AU-PCP experiment results have also validated the superiority of the
Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 4920 IEEE INTERNET OF THINGS JOURNAL, VOL. 10, NO. 6, 15 MARCH 2023

proposed offloading strategy, by comparing it with competition [22] S. Misra, B. E. Wolfinger, M. Achuthananda, T. Chakraborty, S. N. Das,
algorithms, in terms of total valuations, average makespan, and and S. Das, “Auction-based optimal task offloading in mobile cloud
computing,” IEEE Syst. J., vol. 13, no. 3, pp. 2978–2985, Sep. 2019.
success rate. In future work, we intend to study a game-based [23] W. Lu, W. Wu, J. Xu, P. Zhao, D. Yang, and L. Xu, “Auction design
dependent task offloading that can distributively control the for cross-edge task offloading in heterogeneous mobile edge clouds,”
offloading requests released by multiple users. Comput. Commun., vol. 181, pp. 90–101, Jan. 2022.
[24] M. Tao, K. Ota, M. Dong, and H. Yuan, “Stackelberg game-based pricing
and offloading in mobile edge computing,” IEEE Wireless Commun.
Lett., vol. 11, no. 5, pp. 883–887, May 2022.
R EFERENCES [25] M. Malawski, G. Juve, E. Deelman, and J. Nabrzyski, “Algorithms
[1] G. Zhao, H. Xu, Y. Zhao, C. Qiao, and L. Huang, “Offloading tasks for cost-and deadline-constrained provisioning for scientific workflow
with dependency and service caching in mobile edge computing,” IEEE ensembles in IaaS clouds,” Future Gener. Comput. Syst., vol. 48,
Trans. Parallel Distrib. Syst., vol. 32, no. 11, pp. 2777–2792, Nov. 2021. pp. 1–18, Jul. 2015.
[2] Y. Sahni, J. Cao, L. Yang, and Y. Ji, “Multihop offloading of multiple [26] Y. Sun et al., “Collaborative dynamic task allocation with demand
DAG tasks in collaborative edge computing,” IEEE Internet Things J., response in cloud-assisted multiedge system for smart grids,” IEEE
vol. 8, no. 6, pp. 4893–4905, Mar. 2021. Internet Things J., vol. 9, no. 4, pp. 3112–3124, Feb. 2022.
[3] X. Yang, H. Luo, Y. Sun, J. Zou, and M. Guizani, “Coalitional game- [27] L. Yang, B. Liu, J. Cao, Y. Sahni, and Z. Wang, “Joint computation
based cooperative computation offloading in MEC for reusable tasks,” partitioning and resource allocation for latency sensitive applications in
IEEE Internet Things J., vol. 8, no. 16, pp. 12968–12982, Aug. 2021. mobile edge clouds,” IEEE Trans. Services Comput., vol. 14, no. 5,
[4] G.-S. Yao, Y.-S. Ding, and K.-R. Hao, “Multi-objective work- pp. 1439–1452, Sep./Oct. 2021.
flow scheduling in cloud system based on cooperative multi-swarm [28] Z. Bellal, B. Nour, and S. Mastorakis, “CoxNet: A computation reuse
optimization algorithm,” J. Central South Univ., vol. 24, no. 5, architecture at the edge,” IEEE Trans. Green Commun. Netw., vol. 5,
pp. 1050–1062, 2017. no. 2, pp. 765–777, Jun. 2021.
[29] H. M. Fard, R. Prodan, and T. Fahringer, “A truthful dynamic workflow
[5] J. Xu, K. Ota, M. Dong, and H. Zhou, “MCTS-enhanced hybrid offload-
scheduling mechanism for commercial multicloud environments,” IEEE
ing for aerial multi-access edge computing,” IEEE Wireless Commun.,
Trans. Parallel Distrib. Syst., vol. 24, no. 6, pp. 1203–1212, Jun. 2013.
vol. 28, no. 5, pp. 82–87, Oct. 2021.
[30] Z. Gao, M. Liwang, S. Hosseinalipour, H. Dai, and X. Wang, “A truthful
[6] J. Liu et al., “Online multi-Workflow scheduling under uncertain task
auction for graph job allocation in vehicular cloud-assisted networks,”
execution time in IaaS clouds,” IEEE Trans. Cloud Comput., vol. 9,
IEEE Trans. Mobile Comput., vol. 21, no. 10, pp. 3455–3469, Oct. 2022.
no. 3, pp. 1180–1194, Jul.-Sep. 2021.
[31] L. Mashayekhy, M. M. Nejad, D. Grosu, and A. V. Vasilakos, “An Online
[7] J.-W. Hou, S.-Q. Sun, R.-T. Liu, J.-H. Li, and M.-X. Zhang, “Design
mechanism for resource allocation and pricing in clouds,” IEEE Trans.
and achievement of cloud geodatabase for a sponge city,” J. Central
Comput., vol. 65, no. 4, pp. 1172–1184, Apr. 2016.
South Univ., vol. 25, no. 10, pp. 2423–2437, 2018.
[32] Y. Zhang, C. Ji, N. Qiao, J. Ren, Y. Zhang, and Y. Yang, “Distributed
[8] Y. Zhang, “Resource scheduling and delay analysis for workflow in pricing and bandwidth allocation in crowdsourced wireless community
wireless small cloud,” IEEE Trans. Mobile Comput., vol. 17, no. 3, networks,” IEEE Trans. Mobile Comput., early access, May 10, 2022,
pp. 675–687, Mar. 2018. doi: 10.1109/TMC.2022.3174000.
[9] J. Liu and X. Zhang, “Truthful resource trading for dependent task [33] S. Venkataraman, Z. Yang, M. J. Franklin, B. Recht, and I. Stoica,
offloading in heterogeneous edge computing,” Future Gener. Comput. “Ernest: Efficient performance prediction for large-scale advanced ana-
Syst., vol. 133, pp. 228–239, Aug. 2022. lytics,” in Proc. NSDI, 2016, pp. 363–378.
[10] G. Gao, M. Xiao, J. Wu, H. Huang, S. Wang, and G. Chen, “Auction- [34] M. R. Gary and D. S. Johnson, Computers and Intractability: A Guide
based VM allocation for deadline-sensitive tasks in distributed edge to the Theory of NP-Completeness Dallas, TX, USA: Dallas, TX, USA,
cloud,” IEEE Trans. Services Comput., vol. 14, no. 6, pp. 1702–1716, 1979.
Nov./Dec. 2021. [35] H. Topcuoglu, S. Hariri, and M.-Y. Wu, “Performance-effective and low-
[11] X. Peng, K. Ota, and M. Dong, “Multiattribute-based double auction complexity task scheduling for heterogeneous computing,” IEEE Trans.
toward resource allocation in vehicular fog computing,” IEEE Internet Parallel Distrib. Syst., vol. 13, no. 3, pp. 260–274, Mar. 2002.
Things J., vol. 7, no. 4, pp. 3094–3103, Apr. 2020. [36] K. Elgazzar, P. Martin, and H. S. Hassanein, “Cloud-assisted computa-
[12] Y. Zhang, X. Lan, J. Ren, and L. Cai, “Efficient computing resource tion offloading to support mobile services,” IEEE Trans. Cloud Comput.,
sharing for mobile edge-cloud computing networks,” IEEE/ACM Trans. vol. 4, no. 3, pp. 279–292, Jul.-Sep. 2016.
Netw., vol. 28, no. 3, pp. 1227–1240, Jun. 2020. [37] S. Abrishami, M. Naghibzadeh, and D. H. Epema, “Deadline-constrained
[13] W. Huang, K. Ota, M. Dong, T. Wang, S. Zhang, and J. Zhang, “Result workflow scheduling algorithms for infrastructure as a service clouds,”
return aware offloading scheme in vehicular edge networks for IoT,” Future Gener. Comput. Syst., vol. 29, no. 1, pp. 158–169, 2013.
Comput. Commun., vol. 164, pp. 201–214, Dec. 2020. [38] Y.-K. Kwok and I. Ahmad, “Static scheduling algorithms for allocating
[14] J. Liu, J. Ren, Y. Zhang, X. Peng, Y. Zhang, and Y. Yang, “Efficient directed task graphs to multiprocessors,” ACM Comput. Surveys, vol. 31,
dependent task offloading for multiple applications in MEC-cloud no. 4, pp. 406–471, 1999.
system,” IEEE Trans. Mobile Comput., early access, Oct. 11, 2021, [39] R. B. Myerson, “Optimal auction design,” Math. Oper. Res., vol. 6, no. 1,
doi: 10.1109/TMC.2021.3119200. pp. 58–73, 1981.
[15] Y.-H. Kao, B. Krishnamachari, M.-R. Ra, and F. Bai, “Hermes: Latency [40] A. Mu’Alem and N. Nisan, “Truthful approximation mechanisms for
optimal task assignment for resource-constrained mobile computing,” restricted combinatorial auctions,” Games Econ. Behav., vol. 64, no. 2,
IEEE Trans. Mobile Comput., vol. 16, no. 11, pp. 3056–3069, Nov. 2017. pp. 612–631, 2008.
[16] S. Sundar and B. Liang, “Offloading dependent tasks with communi- [41] N. Nisan, T. Roughgarden, E. Tardos, and V. V. Vazirani, Algorithmic
cation delay and deadline constraint,” in Proc. IEEE INFOCOM Conf. Game Theory. Cambridge, U.K.: Cambridge Univ. Press, 2007.
Comput. Commun., 2018, pp. 37–45. [42] C. Sonmez, A. Ozgovde, and C. Ersoy, “Edgecloudsim: An environment
[17] A. Naouri, H. Wu, N. A. Nouri, S. Dhelim, and H. Ning, “A novel for performance evaluation of edge computing systems,” Trans. Emerg.
framework for mobile-edge computing by Optimizing task offloading,” Telecommun. Technol., vol. 29, no. 11, 2018, Art. no. e3493.
IEEE Internet Things J., vol. 8, no. 16, pp. 13065–13076, Aug. 2021. [43] Z. Cai, Q. Li, and X. Li, “Elasticsim: A toolkit for simulating workflows
[18] J. Lee, H. Ko, J. Kim, and S. Pack, “DATA: Dependency-aware task allo- with cloud resource runtime auto-scaling and stochastic task execution
cation scheme in distributed edge clouds,” IEEE Trans. Ind. Informat., times,” J. Grid Comput., vol. 15, no. 2, pp. 257–272, 2017.
vol. 16, no. 12, pp. 7782–7790, Dec. 2020. [44] H. Tan, Z. Han, X.-Y. Li, and F. C. Lau, “Online job dispatching and
[19] Z. Liu et al., “Topology-aware dynamic computation offloading in scheduling in edge-clouds,” in Proc. IEEE INFOCOM Conf. Comput.
vehicular networks,” in Proc. IEEE 93rd Veh. Technol. Conf. (VTC2021- Commun., 2017, pp. 1–9.
Spring), 2021, pp. 1–5. [45] C. Shu, Z. Zhao, Y. Han, G. Min, and H. Duan, “Multi-user offloading
[20] H. Liao, X. Li, D. Guo, W. Kang, and J. Li, “Dependency-aware applica- for edge computing networks: A dependency-aware and latency-optimal
tion assigning and scheduling in edge computing,” IEEE Internet Things approach,” IEEE Internet Things J., vol. 7, no. 3, pp. 1678–1689,
J., vol. 9, no. 6, pp. 4451–4463, Mar. 2022. Mar. 2020.
[21] L. Liu, H. Huang, H. Tan, W. Cao, P. Yang, and X.-Y. Li, “Online DAG [46] G. Juve, A. Chervenak, E. Deelman, S. Bharathi, G. Mehta, and
scheduling with on-demand function configuration in edge computing,” K. Vahi, “Characterizing and profiling scientific workflows,” Future
in Proc. Int. Conf. Wireless Algorithms Syst. Appl., 2019, pp. 213–224. Gener. Comput. Syst., vol. 29, no. 3, pp. 682–692, 2013.

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.
 LIU et al.: AUCTION-BASED DEPENDENT TASK OFFLOADING FOR IoT USERS IN EDGE CLOUDS 4921

Jiagang Liu received the M.Sc. and Ph.D. degrees Ju Ren (Senior Member, IEEE) received the B.Sc.,
in computer science from Central South University, M.Sc., and Ph.D. degrees in computer science from
Changsha, China, in 2007 and 2020, respectively. Central South University, Changsha, China, in 2009,
He is currently an Associate Professor with 2012, and 2016, respectively.
the School of Computer Science and Engineering, He is currently an Associate Professor with the
Hunan Institute of Technology, Hengyang, China, Department of Computer Science and Technology,
and also with Shaanxi Key Laboratory for Tsinghua University, Beijing, China. Prior to that,
Network Computing and Security Technology, he was a Professor with the School of Computer
Xi’an, Shaanxi, China. He has published more than Science and Engineering, Central South University.
five papers, such as TMC, TCC, and FGCS. His His research interests include Internet of Things,
research interests include Internet of Things, edge edge computing, big data, as well as security and
computing, and task scheduling. privacy.
Dr. Ren received many best paper awards from IEEE flag ship confer-
ences, including IEEE ICC’19, IEEE HPCC’19, IEEE TCSC Early Career
Researcher Award in 2019, and IEEE ComSoc Asia–Pacific Best Young
Researcher Award in 2021. He is recognized as a Highly Cited Researcher
by Clarivate in 2020. He currently serves/has served as an Associate Editor
of the IEEE T RANSACTIONS ON V EHICULAR T ECHNOLOGY and Peer-to-
Peer Networking and Applications, a Guest Editor of the IEEE W IRELESS
C OMMUNICATIONS, IEEE T RANSACTIONS ON I NDUSTRIAL I NFORMATICS
and IEEE N ETWORK, and a TPC member of many international conferences,
including IEEE INFOCOM’22/21/20/19/18 and ICDCS’22/21. He also served
as the General Co-Chair for IEEE BigDataSE’20, the TPC Co-Chair for IEEE
BigDataSE’19, a Poster Co-Chair for IEEE MASS’18, a Track Co-Chair for
IEEE/CIC ICCC’19, IEEE ISPAN’18 and VTC’17 Fall, and an active reviewer
for more than 20 international journals.

Yongmin Zhang (Senior Member, IEEE) received

the Ph.D. degree in control science and engineering
from Zhejiang University, Hangzhou, China, in Yaoxue Zhang (Senior Member, IEEE) received
2015. the B.Sc. degree from the Northwest Institute of
From 2015 to 2019, he was a Postdoctoral Telecommunication Engineering, Xi’an, China, in
Research Fellow with the Department of Electrical 1982, and the Ph.D. degree in computer networking
and Computer Engineering, University of Victoria, from Tohoku University, Sendai, Japan, in 1989.
Victoria, BC, Canada. He is currently a Professor He is currently a Professor with the Department
with the School of Computer Science and of Computer Science and Technology, Tsinghua
Engineering, Central South University, Changsha, University, Beijing, China. He has published more
China. His research interests include Internet of than 200 papers on IEEE/ACM journals and con-
Things, smart grid, and mobile computing. ferences. His research interests include computer
Dr. Zhang won the Best Paper Award of IEEE PIMRC 2012 and the IEEE networking, operating systems, and transparent
ComSoc Asia–Pacific outstanding paper Award 2018. He currently serves on computing.
the editorial board of Journal of Communications and Networks and Journal Prof. Zhang is the Editor-in-Chief of Chinese Journal of Electronics and a
of Central South University. Fellow of the Chinese Academy of Engineering.

Authorized licensed use limited to: COMSATS INSTITUTE OF INFORMATION TECHNOLOGY. Downloaded on November 08,2024 at 15:57:08 UTC from IEEE Xplore. Restrictions apply.