This article has been accepted for publication in a future issue of this journal, but has not been

fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Date of publication xxxx 00, 0000, date of current version xxxx 00, 0000.
Digital Object Identifier 10.1109/ACCESS.2018.DOI

On Minimizing Sensing Time via Data

Sharing in Collaborative Internet of
Things
WEIWEI WU1 , (Member, IEEE), XIANGPING (BRYCE) ZHAI2 , (Member, IEEE),
YINGCHAO ZHAO3
1
School of Computer Science and Engineering, Southeast University, Nanjing, Jiangsu, P. R. China (email: weiweiwu@seu.edu.cn)
2
College of Computer Science and Technology, Nanjing University of Aeronautics and Astronautics, Nanjing, China (email: blueicezhaixp@nuaa.edu.cn)
3
School of Computing and Information Sciences, Caritas Institute of Higher Education, Hong Kong. (email: zhaoyingchao@gmail.com)
Corresponding author: Xiangping Zhai (e-mail: blueicezhaixp@nuaa.edu.cn).
This work is supported in part by National Key RD Program of China 2017YFB1003000, National Natural Science Foundation of China
under Grants No. 61672154, No. 61701231, Research Grants Council of the Hong Kong Special Administrative Region, China [Project
No. UGC/FDS11/E04/15], and Key Laboratory of Computer Network and Information Integration (Southeast University), Ministry of
Education.

ABSTRACT
In order to improve the utilization efficiency of Internet of Things (IoT), more collaboration is preferable in
the collection and exchange of data. When multiple applications/tasks request data from a sensor, we can
make use of data sharing among the tasks as long as the data meets the time-sensitive QoS requirements
of the tasks. This would in turn reduce both the total sensing time and the energy consumption, which is
a significant concern in IoT systems. A practical question is how to design an efficient schedule to enable
more data sharing and less sensing time. This paper addresses such a problem by developing algorithms
with performance guarantees, respectively for the offline and online scenarios. Two task models are studied
respectively, FIFO (first-in-first-out) task model and AD (arbitrary deadline) task model. We first provide
an optimal algorithm for FIFO tasks in the offline case, then we study the online case, in which data requests
arrive dynamically without prior information. For FIFO tasks, we develop an online 2-competitive algorithm
that always incurs a total sensing time no more than two times of the optimal solution. For AD tasks, we
devise an online algorithm that is O(log L)-competitive where L is the maximum length of the time duration
of the tasks. Simulation results validate the efficiency of our online algorithms.

INDEX TERMS Scheduling; Internet of things; Data Sharing; Collaboration; Sampling; Sensing time;
Algorithms;

I. INTRODUCTION
NTERNET of Things (IoT) enables the data collection
I and exchange by connecting various objects/things, which
has created many exciting applications, e.g., smart cities,
smart grids, and mobile crowdsensing ( [1], [7], [18], [23]).
In an IoT system, there is usually a group of sensors as data
providers and a central platform as the coordinator. Multiple
applications could submit their data requests to the platform
and these requests would be allocated to the sensor nodes as
tasks; then the sensor nodes would perform the sensing tasks
and transmit the sensed data to the platform.
A platform simply connects the sensors without further
collaboration among data provider and requester, and it
may not be able to fully exploit its utilization and the ef-
ficiency of sensors, energy, data, etc. In order to improve
data collaboration and increase the overall efficiency of the
platform, many research efforts have been invested in the
possible collaboration strategies. However, most of the pre-
vious works consider the sensing as an independent process
and ignore the collaboration from the data sharing aspect.
Although the arrival time and data amount required by each
requester may be different, the sensed data can be shared by
multiple requesters or applications as long as the data meets
its time-sensitive QoS requirements, which would further
save energy as well as data traffic [8], [13]. For example, in
traffic monitoring sensor network systems, there are many

VOLUME 4, 2016 1

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access
Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS
FIGURE 1: An example showing two schedules with differ-
ent total sensing time via data sharing.
applications in the control center platform, such as driving
directions computation, traffic characterization, congestion
prediction, cab fleet management or urban planning tools
[12], which may request remote data, such as volume and
average speed of traffic sampled, from a road traffic sensor.
These information may be requested (in different time or for
different amounts) by different applications, therefore, the
road traffic sensors could combine and share the sensed data
among different requests. Besides, in participatory sensing
systems, data sensed from smartphones may be shared or
requested by multiple applications, which submit requests
through tasks to the central platform [15].
We use an example shown in Fig. 1 to illustrate that the col-
laboration via data sharing among requesters can be exploited
to reduce the energy consumption and data traffic. There are
two data sampling requests, where the first application/task
J1 arrives at 8am and departs at 1am, and task J2 arrives
at 11am and departs at 15pm. Each task requires a sensing
service in a continuous interval with a length of 2 hrs in its
specified period. Fig. 1 shows two schedules. The first one
schedules the sensing tasks by independent sampling in two
isolated periods, which meets the sensing requirements of
the tasks and incurs a total sampling time of 4 hrs. While
the second schedule exploits data sharing between different
requests by overlapping the sensing period of these two tasks,
which results in a reduced sampling time of 3 hrs. We can
see from Fig. 1 that, the first schedule incurs more sampling
because no data sharing between the tasks is exploited, which
indicates a longer sensing time in the sensing process (and
also, more overhead in the data transmission) for the sensor
node; while the second schedule exploits the data sharing
between tasks and reduces the data sampling, resulting in less
sensing time (and also, less overhead of data transmission).
The example above shows that the overhead of sensing and
data transmission can be reduced by exploiting the data shar-
ing among requesters. Thus, we refer to the sampling time
caused by a schedule to be the active sensing time or sensing
time for short in this paper, which measures the overhead of
the sensor participating in the sensing and transmission of
data. In this paper, we investigate the data sharing problem to
minimize the total sensing time.
Recently, there are a few works that investigate the pos-
sible collaboration in Internet of Things [4], [6], [10], [22].
2 VOLUME 4, 2016
2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
For example, [10] proposes a collaborative framework to
integrate real-time traffic information from different data
sources of the intelligent transportation system; [22] pro-
poses collaborative location-based sleep scheduling schemes
to minimize the energy consumption for wireless sensor
networks; [6] considers location-aware collaborative sensing
and design auctions to stimulate the participants to join mo-
bile crowdsensing applications; [16] considers probabilistic
collaboration for multiple mobile users to minimize the over-
all cost when cooperatively performing a common sensing
task; [9] introduces a collaboration protocol to share health
information between IoT personal health devices; [4] pro-
poses a collaborative sensing intelligence (CSI) framework
to facilitate the cooperativity of data analytics and discusses
the open issues and challenges; [21], [24] introduce the meth-
ods/types of sensor-cloud to deliver and process big data in
internet of things. These works, however, have not exploited
the collaboration in sensing process from the aspect of data
sharing. In [12], Tavakoli et al. first formulate the data shar-
ing problem to minimize the total sampling time in wireless
sensor networks [12], where each application/request needs
to sample discrete data at some time points, and these data
can be shared by multiple requests. Zhao et al. [20] propose
a 2-approximate algorithm to maximize the data sharing. Wu
et al. [14], [15] consider rate-adaptive scheduling policies to
address the trade-off between the transmission redundancy
and energy consumption. Fang et al. [5] further extend the
work in [12] by considering continuous sampling requests
that require a continuous interval of sampling data. The
overlapped interval of data can also be shared by other
requests. They develop an offline algorithm to reduce the total
sampling time, which guarantees a factor 2 of approximation
to the optimal solution. Zhao et al. [19] consider the fairness
among sensors when scheduling tasks by optimizing the min-
max aggregate sensing time.
In this paper, we investigate the data sharing problem to
minimize the total sensing time under the scenario of contin-
uous sampling requests. We note that no prior works have
provided online algorithms with theoretical performance
guarantee. In this paper, we provide optimal solutions for
the offline scenario and further consider the practical online
arrivals of tasks by developing online competitive algorithms
with performance guarantee. We measure the performance of
online algorithms with the paradigm of competitive analysis
[2], which guarantees that the total sensing time incurred by
an online algorithm is always no more than a bounded factor
of the optimal offline solution for all possible inputs.
We consider the following two task models, FIFO task
model and AD task model. The former typically models the
FIFO schedulers with first-in-first-out service rule that earlier
arrival tasks have earlier deadlines [3], [11]; while the latter
generalizes the setting in the former to deal with the tasks
with arbitrary deadlines.
In this paper, we provide an optimal algorithm for the
offline setting and develop online algorithms with proven
worst-case performance bounds, in both the FIFO task model
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access
Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS
and AD task model. Due to the lack of information and the
complicated structure of the optimal solution, it is difficult
to directly bound the performance of online algorithms. To
this end, we first propose decomposition methods to parti-
tion the tasks into subsets with well-characterized properties
(e.g. pairwise intersecting, disjoint property); then, we devise
novel algorithms/analysis to tackle the partitioned tasks and
combine the results, which guarantees to have bounded ap-
proximation performance.
Our contributions are summarized as follows.
• This paper investigates the data sharing problem to
minimize the total sensing time in collaborative Internet
of Things. We provide optimal offline solutions and
online competitive algorithms with theoretical perfor-
mance guarantees under the continuous sampling re-
quest model.
• For the offline setting, we provide an optimal algorithm
for FIFO tasks. The method is to develop a basic optimal
procedure (named LAF) for pairwise intersecting tasks,
based on which, we then develop a dynamic program-
ming algorithm to compute the optimal solution for
FIFO tasks.
• For the online setting, we develop a 2-competitive algo-
rithm for FIFO tasks, which guarantees that the incurred
total sensing time is no more than two times of the
optimal solution. Our method is to decompose the input
tasks online into two groups and apply LAF to compute
the respective optimal solution for each of them.
• For online AD tasks, we develop an online algorithm
that guarantees an O(log L)-competitiveness where L
is the maximum length of the time duration of the tasks.
The remains of this paper are organized as follows. In Sec-
tion II, we formulate the model and introduce the undertaken
problem. In Section III, we provide the optimal algorithm
for the offline setting. In Section IV, we study the FIFO
task model and develop an online algorithm with proven 2-
competitiveness. We further investigate the generalized AD
task model by developing an O(log L)-competitive algorithm
in Section V. Section VI performs simulations for our online
algorithms and validates their efficiency. Finally, we con-
clude the paper in Section VII.
II. PRELIMINARIES
In this section, we first introduce the system model, and then
present the problem formulation.
A. SYSTEM MODEL
In an IoT system, there are usually a group of sensors as
data providers and a central platform as the coordinator.
Multiple applications could submit their data requests to the
platform to request the data from sensors. We model a QoS-
constrained data request as a task with an arrival time and a
deadline, specifying the timeliness of the data request. The
time is partitioned into discrete time slots, where the interval
(t1 , t2 ] has t2 − t1 time slots. A task Ji , i = 1, . . . , n, can
be defined by (ri , di , pi ), where ri is the arrival time, di is
VOLUME 4, 2016
2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
the deadline, and pi is the workload/number of sensing time
slots required by Ji where pi ≤ di − ri . For simplicity,
we just say task Ji arrives at ri and departures at di . Let
L = max1≤i≤n di − ri be the longest length of the time
duration of the tasks. All tasks form the input task set
J = {J1 , J2 , ..., Jn }.
Without loss of generality, we assume that mini ri = 0
and maxi di = T . Also, ri (di ) is called an arrival (deadline)
time/point, and consequently, from time 0 to T , there are 2n
such points. For each task Ji = (ri , di , pi ), we say that task
Ji remains alive at t ∈ (ri , di ].
We consider the continuous sample requests that the sens-
ing task should be performed in a continuous period with a
length of pi in the time duration (ri , di ], which is called the
delay/time constraint. That is, the allocated sampling interval
for satisfying the workload of Ji should be of length pi .
Given a schedule, we use (si , fi ] to denote the allocated sens-
ing period for task Ji where fi − si should be pi . We say task
Ji is satisfied when a continuous sub-interval with length pi
in (ri , di ] is scheduled to sample data and fulfill the workload
requirement of Ji . To be specific, there are di − ri − pi + 1
feasible candidate sub-intervals to be allocated for task Ji ,
i.e., (ri , ri + pi ], (ri + 1, ri + pi + 1], . . . , (di − pi , di ]. Thus,
si ∈ [ri , di − pi ] and it determines the starting time as well
as the corresponding sensing interval allocated for task Ji .
A scheduling algorithm should generate a sched-
ule/allocation S that specifies the sensing time period in
interval (0, T ] to meet the workload requirement of the tasks.
Let s(t) = 1 if time slot t is allocated to be a sensing time,
and we say t is an active sensing time slot or sensing time slot
for short; otherwise, s(t) = 0 and we say t is an idle/sleep
time slot. Note that the total number of active sensing time
slots can be used to measure both the overhead in the sensing
and the transmission of data for the sensor.
In this paper, we consider two task models, FIFO task
model and AD task model. The first one naturally models
a FIFO scheduler ( [3], [11], [17]) which follows the first-
in-first-out service rule, i.e., where tasks have deadlines in
the same order as their arrival times. That is, di ≤ dk if
ri ≤ rk . The AD task model further generalizes FIFO model
to tasks with arbitrary deadlines to model the most general
QoS requirements.
B. PROBLEM FORMULATION
We introduce a data sharing problem where a sensor node
needs to sample (and transmit) the data, shared by multiple
tasks, to the central platform with the minimum sensing time.
The sensed data can be shared by multiple tasks as long as
it fits in the time intervals of the tasks. A feasible schedule
must fulfill the data requirements of all tasks within their
delay constraints. That it,
X
s(t) ≥ pi , ∀Ji . (1)
ri <t≤di
Note that the data sensed at time slot t can be shared by
(or equivalently used to meet the requirement of) any task
3
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access
Ji alive at time t ∈ (ri , di ]. By exploiting data sharing, the
number of allocated sensing time slots can be reduced, which
in turn would reduce the sensing overhead (as well as the
transmission overhead) for the sensor node.
The total sensing time incurred by an algorithm ALG,
denoted as ALG(J), is
ALG(J) =
X
s(t).
0<t≤T
Here, the allocation function s(t) is an important variable
to be determined in the schedule. Note that ALG(J) mea-
sures how many sampling operations should be performed
and how much data should be transmitted back to remote
platform, both of which are significant for energy efficiency.
Therefore, in this paper, we consider an energy-efficient
scheduling problem to minimize the total sensing time, as
defined below.
Definition 1. The energy-efficient data sharing problem is
to determine the sensing time allocation function s(t) so as
to minimize the total sensing time (2) while meeting all the
delay constraints (1).
We will investigate both the offline and online scenarios
of the problem. In the offline setting, full task information
is known, while in the online setting, tasks arrive over
time without prior information. An online algorithm needs
to decide the scheduling strategy on the arrival of tasks,
without relying on any distribution or future information.
We adopt the paradigm of competitive analysis, which is
widely used to measure the worst-case performance of online
algorithms, where an online algorithm ALG is compared
with the optimal offline algorithm OP T with full information
(as benchmark).
To simplify the presentation, we use OP T (or sopt (t)) to
represent the optimal solution. An online algorithm is said γ-
competitive if it always outputs a solution within γ times of
the optimal offline solution for any input σ (which is a set of
tasks to be served in this paper). That is,
ALG(σ)
≤ γ, ∀σ
OP T (σ)
where ALG(σ), OP T (σ) are the total sensing time incurred
by the online algorithm and the optimal offline algorithm
respectively for a given input σ.
Thus, this paper aims at designing both offline algorithms
and online algorithms with proven performance bounds to
minimize the total sensing time.
III. FIFO TASKS: THE OPTIMAL ALGORITHM
In this section, we develop an optimal offline algorithm for
FIFO tasks.
For ease of presentation, we first show some definitions
and a basic lemma which will be used for all the cases
throughout the paper.
4 VOLUME 4, 2016
2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS
Definition 2. We define a block to be the maximal interval
containing only active sensing time. We say a task belongs to
a block if this task is executed within the block’s duration.
Definition 3. We define the latest starting time (LST ) for Ji
to be LSTi = di − pi and the earliest latest-starting-time of
a task set J to be ELST (J) = minJi ∈J {LSTi }.
(2) Definition 4. We say two tasks Ji and Jk intersect if (ri , di ]∩
(rk , dk ] 6= ∅. We say tasks in set J are pairwise intersecting
if any two tasks in that set intersect with each other.
Lemma 1. There exists an optimal schedule such that the
starting time of each block is ELST (Y), where Y is a
(certain) set of tasks executed in this block.
Proof. First, the starting time of the block cannot be later
than ELST (Y) since it will violate some job’s deadline. On
the other hand, if the starting time of the block is earlier than
ELST (Y), then we can push the starting time of the block
to ELST (Y), by postponing every job’s starting time by the
same amount. This gives us a new block with the same length.
However, moving every job’s execution by the same amount
may violate some job’s deadline. When that happens, we just
keep those jobs’ starting time at their LST s. All these LST s
are at least ELST (Y). This will give us a feasible schedule
with a sensing time no more than the length of the original
block, and meanwhile the block starts at ELST (Y).
In the following discussions, we will first propose a basic
procedure for pairwise intersecting tasks, and then we will
develop an optimal algorithm for FIFO tasks.
A. A BASIC PROCEDURE FOR PAIRWISE
INTERSECTING TASKS
Given a set J of pairwise intersecting tasks, we propose a
basic procedure to output the optimal schedule.
The proposed procedure, named LAF (Latest-and-Follow),
works as follows. Given a task set J that is pairwise intersect-
ing, we first compute the latest time ELST (J). Suppose that
Jk achieves such a latest starting time among the tasks in
set J. Then, Jk will start its execution at the latest starting
(3)
time, i.e., it is allocated to the period (dk − pk , dk ]. For
each task Jm ∈ J\{Jk }, it will be allocated to the period
overlapping with Jk as much as possible. i.e., the period
(sm , sm + pm ] where sm = max{rm , ELST (Y)} for all
m 6= k. That is, it will be executed as early as possible
without being earlier than ELST (Y) or rm . Note that all
tasks in set J intersect with Jk since J is composed of
pairwise intersecting tasks. Thus, LAF will generate a single
block with continuous sensing time for pairwise intersecting
tasks, i.e., it will execute all the tasks without idle time in
between. Fig. 2 shows an exemplary schedule generated by
LAF. The detailed implementation is presented in Algorithm
1.
Lemma 2. Algorithm LAF returns the optimal schedule for
pairwise intersecting tasks.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS
FIGURE 2: A schedule generated by LAF over pairwise
intersecting tasks.
Algorithm 1 LAF
1: for each task Ji , find its latest starting time LSTi .
2: suppose that Jk achieves the earliest/minimum LST
among the tasks, i.e. LSTk ≤ LSTm for any m 6= k.
3: start the execution of task Jk at its latest starting time,
i.e., set s(t) = 1 for all t ∈ (dk − pk , dk ]
4: for any other task Jm with m 6= k, allocate
it to (max{rm , LSTk }, max{rm , LSTk }
pm ], i.e., set s(t) = 1 for all t
(max{rm , LSTk }, max{rm , LSTk } + pm ].
Proof. By Lemma 1, there exists an optimal schedule that
starts at ELST (J). Assume that Jk is the task that has
the latest starting time, i.e., Jk = arg minJi ∈J {LSTi }
and fk = dk . Note that LAF exactly starts the execution
from ELST (J). As any two tasks in J intersect, any task
in J intersect with Jk . Thus, for any other task Jm ∈
J\{Jk }, its latest starting time is no smaller than LSTk .
Moreover, in LAF, task Jm is executed at the starting time
max{rm , ELST (J)}. Among these tasks, assume that Ju is
the one with the largest finish time, fu = maxJi ∈J,i6=k fi .
Obviously, the total sensing time allocated by LAF is
min{fu , fk } − sk . If ru < sk , then su = sk in LAF;
any optimal schedule satisfying the requirements of Ju and
Jk should also allocate at least min{fu , fk } − sk sensing
time. If ru > sk , then the schedule in LAF has shared as
much sensing time for Ju and Jk as possible; any optimal
schedule satisfying Ju and Jk should also allocate at least
min{fu , fk } − sk sensing time. Therefore, LAF returns the
optimal schedule for pairwise intersecting tasks.
B. OPTIMAL ALGORITHM FOR FIFO TASKS
Now we develop an optimal algorithm for FIFO tasks. Our
idea is to show that an optimal schedule can be found by
grouping the tasks into different blocks sequentially and then
picking the combination of blocks where the total length of
the blocks is minimized.
We first present a property for the optimal solution.
Lemma 3. For FIFO tasks, there exists an optimal schedule
S such that the tasks are processed in the order of their ar-
rival times and the starting time of each block is ELST (Y),
VOLUME 4, 2016
2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
10.1109/ACCESS.2018.2859357, IEEE Access
FIGURE 3: The transformation for schedules that do not
follow the processing order of arrival times.
where Y is the set of tasks executed in the same block in S.
Proof. Let J be the set of n jobs, where the tasks are sorted
+ by arrival times such that r1 ≤ r2 ≤ · · · ≤ rn . For tasks with
∈ the same arrival time, they are sorted by increasing deadlines.
Let S be an optimal schedule where the starting time of each
block is ELST (Y), which does not follow the processing
order of arrival times. In other words, there exists a pair of
jobs, Ji and Jk , with ri < rk (or ri = rk and di < dk )
and Jk is scheduled before Ji . We have two cases to discuss,
which are pi ≤ pk and pi > pk .
In the first case, since ri ≤ rk and pi ≤ pk , it is feasible to
start task Ji at sk without exceeding its deadline di . Because
pi ≤ pk , if both tasks start at the same time point, the task
execution of Jk can cover up the whole execution of task Ji .
Therefore, we can always set si to be sk without increasing
the number of sensing time slots, as illustrated in Fig. 3(a).
In the second case, since pi > pk , the execution of task Ji
can cover up the whole execution of task Jk . Since di ≤ dk .
we can start task Jk at si without exceeding its deadline dk .
Therefore, we can schedule both tasks at the same time point
si without increasing the total sensing time in an optimal
schedule, as illustrated in Fig. 3(b).
Besides, as indicated by Lemma 1, we can push the starting
time of the blocks to ELST (Y) by postponing every job’s
starting time by the same amount. Let Jk be the task with the
earliest latest-starting-time in a block. After pushing the jobs,
the tasks Ji with ri ≤ rk can always be scheduled at the same
time with the task Jk at ELST (Y). Hence, the tasks remain
processed in the order of their arrival times.
Thus, we show that in any case, an optimal schedule can be
obtained where the tasks are processed in the order of arrival
times and the starting time of each block is ELST (Y).
Based on the property above, we can see that each block
in the optimal solution starts at a time ELST (Y) where Y
is a subset of the input J; moreover, the tasks in set Y have
continuous index, e.g., Y = {Ji , Ji+1 , . . . , Jk } since tasks
are executed in the order of their arrival times. Thus, we can
enumerate the set Y = {Ji , Ji+1 , . . . , Jk } that consists a
5
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

block in the optimal solution by enumerating indexes i and k.

When these two indexes are correctly found, the total sensing
time of that block can be calculated by applying LAF to the
task set Y = {Ji , Ji+1 , . . . , Jk }. Thus, we use LAF (i, k)
to denote the minimum total sensing time used to execute
tasks from Ji to Jk without idle time in between. We write
LAF (i, k) = ∞ if the resulting schedule consists of more
than one blocks, which is used for tackling the case that the
input Y is not correctly enumerated. We use Block(i, k) to
represent the block itself generated by LAF (i, k).

Algorithm 2 DP (J)
sort the tasks by arrival times in increasing order, where FIGURE 4: The two decomposed groups Godd and Geven ,
r1 ≤ r2 ≤ · · · ≤ rn . each of which is composed of several disjoint sets. Each set
for i = 1 to n, k = 1 to n do Si consists of pairwise intersecting tasks that intersect at ti .
apply algorithm LAF over tasks from Ji to Jk to com-
pute a block with continuous sensing time, where the re-
sulting length of the block is denoted as LAF (i, k); if it Theorem 1. Algorithm DP can compute an optimal schedule
results in more than one block, we set LAF (i, k) = ∞. for FIFO tasks in O(n3 ) time.
Proof. In the initialization step, the indices of tasks are
end for sorted by arrival time in non-decreasing order, breaking ties
for i = n to 1 do by increasing deadlines. Then we implement the dynamic
for j = i to n do programming process in a bottom-up manner to calculate an
optimal schedule. The optimality of the algorithm follows by
(
LAF (i, j) the correctness of the derived recursive function.
OP T (i, j) = min min OP T (i, k) + LAF (k + 1, j) The algorithm is conducted in two phases. In the first
i≤k≤j
(4) phase, the algorithm computes LAF (i, k) with different i
end for and k in O(n3 ) time since each block needs O(n) time
end for to calculate. In the second phase, the algorithm calculates
OP T (i, j) where each needs O(n) time to find the mini-
mum. Therefore, the overall running time of the algorithm
Now, we propose an algorithm to compute the optimal is O(n3 ).
schedule for FIFO tasks. We use OP T (i, k) to represent the
minimum total sensing time needed to execute tasks from
IV. FIFO TASKS: A 2-COMPETITIVE ONLINE
Ji to Jk . Then, OP T (1, n) is the total sensing time of the
ALGORITHM
optimal solution. By Lemma 3, the last block of the optimal
In the previous section, we have provided an optimal algo-
solution starts at ELST (Y) where Y should be a subset of
rithm for FIFO tasks in the offline setting. In this section, we
tasks with continuous indexes. Without loss of generality, we
develop an online algorithm for FIFO tasks that guarantees a
assume that Y = {Ji |k + 1 ≤ i ≤ n}. Accordingly, the last
competitive ratio of 2.
block Block(k + 1, n) can be computed by LAF (k + 1, n).
In the online setting, the information of Ji is not available
While for the remaining blocks of the optimal solution, they
until ri . Therefore, the algorithm is based on the available
are disconnected with the block Block(k + 1, n); thus, these
jobs’ information to find the best schedule. It is difficult to
blocks can be returned by OP T (1, k). Therefore, the total
directly derive an online algorithm with performance guar-
sensing time of an optimal schedule for all the tasks can be
antee.
calculated as follows.
Instead, our method is to decompose the tasks into two
groups that consists of several disjoint sets first; then, we
( apply the schedule LAF proposed in the previous section to
LAF (1, n) output an optimal online schedule for each group of tasks;
OP T (1, n) = min
min1≤k≤n OP T (1, k) + LAF (k + 1, n) finally, we obtain an online algorithm, named FFS (FIFO
(5) Schedule), by merging the results.
where OP T (i, i) is equal to the processing time of Ji which Fig. 4 shows an example for the decomposition process,
is pi . which works as follows. On the arrival of a newly arrived
After deriving the recursive function, we can implement task, we mark its deadline to be t1 . For all arriving tasks, if
it in a bottom-up manner to compute the optimal solution. they intersect with t1 , we move them to the set G1 ; otherwise,
Algorithm 2 presents the detailed implementation. we find the first task that does not intersect with t1 and mark
6 VOLUME 4, 2016

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access
Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS
its deadline to be t2 . Similarly, we can move the tasks that
intersect with t2 to set G2 . Gradually, we can obtain several
sets, say G1 , G2 , . . . , Gz . Obviously, each set is composed of
pairwise intersecting tasks. For these sets, we make the sets
with odd index form a group Godd and the others form a group
Geven .
Based on the decomposition, we apply LAF to the odd
group Godd of tasks and the even group Geven of tasks to
generate two schedules, respectively. Assume that sodd (t)
(and seven (t)) is the function specified by LAF when running
on Godd (and Geven ), indicating whether time slot t is active
or idle. We note that the two groups can be obtained online
in the decomposition step and LAF can also work online
for pairwise intersecting tasks. Accordingly, we can have
the values sodd (t) and seven (t) in an online manner, which
satisfies the feasibility for tasks in the odd group and the
even group, respectively. Finally, we combine these two
schedules to generate a final schedule. That is, we simply
specify the final function s(t) = max{sodd (t), seven (t)}
in our schedule. Obviously, such a function can satisfy the
workload requirements of all tasks in the two groups by
the nature of the max operation. Algorithm 3 presents the
detailed implementation.
Algorithm 3 FFS
1: run online decomposition process to decompose the tasks
into the odd group Godd and even group Geven .
2: run Algorithm LAF online over tasks in Godd to deter-
mine the function sodd (t) at time t.
3: run Algorithm LAF online over tasks in Geven to deter-
mine the function seven (t) at time t.
4: determine the schedule at time t to be s(t) =
max{sodd (t), seven (t)}.
Now we show the theoretical guarantee of the proposed
algorithm. We prove that the algorithm can guarantee a
competitive ratio of 2. Given a set G of tasks, let I(G) =
{(minJi ∈G ri , maxJi ∈G di ]} be the interval of that set. We
first show that: 1) according to the decomposition process
above, any decomposed set Gl are formed by pairwise inter-
secting tasks, and 2) for any two sets in same (odd or even)
group, their intervals are disjoint with each other.
Lemma 4. The decomposition process has the following
properties,
1) any decomposed set Gl are composed of pairwise inter-
secting tasks.
2) for any two sets Gl , Gl0 in the same group Godd (or Geven ),
we have I(Gl ) ∩ I(Gl0 ) = ∅.
Proof. The first property can be easily verified since the
decomposition always chooses a time slot and makes the
tasks alive at that time form the same set.
We prove the second property as follows. Consider any
two tasks Jp , Jq that belongs two sets Gl , Gl+2 respectively.
Assume task Jk in set Gl+1 that has a deadline dk = tl+1 .
It must arrive after tl since it is not selected in Sl . Task Jp
VOLUME 4, 2016
2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
arrives by time tl , i.e., rp ≤ tl < rk . Thus, dp ≤ dk = tl+1
since they follow first-in-first-out rule. Furthermore, rq >
tl+1 . Therefore, we have dp < rq and hence the intervals
of Jp , Jq are disjoint. Thus, we have I(Gl ) ∩ I(Gl0 ) = ∅
with l 6= l0 for any Gl , Gl0 in the same group.
Based on the property above, we then show our final
schedule achieves a competitive ratio of 2. The intuition is
that the schedule generated by LAF running on a single group
(Godd or Geven ) can be proved to be optimal, hence our final
schedule that combines the results returned by these two
groups uses at most two times of the optimal sensing time.
Theorem 2. Algorithm FFS guarantees a competitive ratio
of 2.
Proof. Let OP T (J) be the minimum sensing time in the
optimal solution and F F S(J) be the solution returned by
algorithm FFS. The original tasks is grouped into two groups,
the odd group and the even group. By Lemma 4, each set in
the same group is composed of pairwise intersecting tasks.
When applying LAF to such a set, it always outputs an
optimal schedule with the minimum sensing time for that
set. Moreover, the intervals of any two sets in the same
group are disjoint by the second property of Lemma 4. Thus,
LAF can always output an optimal schedule for tasks in
the same group, which is sodd (t) for the odd group and
even
sP (t) for the even groups. Therefore,
P we have OP T (J) ≥
odd even
0<t≤T s (t) and OP T (J) ≥ 0<t≤T s (t).
Note that FFS applies LAF on the odd group and
even group respectively and returns a combined function
odd odd
s(t) = max{s P (t), s (t)} P in the final schedule. We have
F F S(J) = 0<t≤T s(t) ≤ 0<t≤T sodd (t) + sodd (t) ≤
2 · OP T (J). Therefore, online algorithm FFS achieves a
competitive ratio of 2.
V. AD TASKS: A LOGARITHMIC COMPETITIVE ONLINE
ALGORITHM
In this section, we consider tasks with arbitrary deadlines.
We will develop an online algorithm with logarithmic com-
petitiveness.
For tasks with arbitrary deadlines, the optimal solution has
much more complex structures since the time intervals of the
tasks can intersect with each other in an irregular manner,
which makes it difficult to design online algorithms with
performance guarantee.
To address it, we will develop an online algorithm, named
ADS (Arbitrary-deadline Schedule), by refining the instance
of input tasks and developing a new decomposition method.
Our idea is to refine the length of the interval of each task
to be a value of two to a certain power first; then, we move
the refined tasks with the same length of interval to the same
group, and generate a virtual schedule by applying FFS to
each group of refined tasks considering that they are actually
FIFO tasks; finally, we generate a real schedule by doubling
the allocated sensing time in a proper way to guarantee the
7
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

feasibility, i.e., satisfying the requirements of the original Algorithm 4 ADS

tasks.
The detailed design is as follows. On the arrival of each
task Ji , we refine its interval (ri , di ] to be (r̂i , dˆi ] = (ri , ri +
2blog(di −ri )c ]. That is, the deadline is advanced and the dura-
tion of the request is shorten to be 2blog(di −ri )c , an integer
of two to a certain power that is closest to but no greater
than the original length di − ri . Accordingly, the workload
requirement is modified to be p̂i = min{pi , dˆi − r̂i }.
Note that pi ≤ 2p̂i since the refined length dˆi − r̂i is
at least one half of di − ri . Let the tasks with the same
refined length form the same group, which is denoted as
Gl = {Ji |2blog(di −ri )c = 2l }. Accordingly, we can obtain
blog Lc + 1 groups, each of which are formed with refined
tasks that follows FIFO order. Note that the tasks can be
assigned to its group in an online manner when the task
arrives. Thus, we apply online algorithm FFS to tasks in
each group to generate a virtual schedule and obtain the
corresponding function ŝl (t) for the refined tasks in the same
group. Here, ŝl (t) is always feasible to satisfy the refined
tasks (each of which require p̂i sensing time) but may be un-
feasible for the original tasks (each of which require pi ≤ 2p̂i
sensing time) . Furthermore, we note that algorithm FFS will
decompose the tasks in the same group into two sub-groups
(each of which is composed of disjoint sets of pairwise
intersecting tasks) and call the basic procedure LAF to run
over the pairwise intersecting tasks. Recall that the output
of LAF over pairwise intersecting tasks is a single block
with continuous sensing time, which guarantees to satisfy
the p̂i workload requirement of the refined task Ji . Thus,
in order to satisfy the original pi workload of the original
task, it is sufficient to extend each block (enlarging its end
time) by doubling the length of the block; moreover, as the
deadline dˆi is advanced in the refined task, the extension will
not violate the original deadline di of the task. Denoted by
sl (t) the schedule that is obtained by extending the blocks
returned in FFS. Finally, we determine our final schedule to
be s(t) = max0≤l≤blog Lc sl (t). Algorithm 4 presents the
detailed implementation.
Now we show the performance guarantee of the proposed
algorithm. We prove that it guarantees a logarithmic compet-
itive ratio.
Theorem 3. Algorithm ADS guarantees a competitive ratio
of 4(blog Lc + 1).
Proof. Let OP T (J) be the minimum sensing time of the
optimal solution with the input of tasks in J. Let F F S(J)
and ADS(J) be the sensing time incurred by algorithm FFS
and ADS running with the input of tasks J, respectively.
Note that each group Gl is composed of refined tasks
that have the same length of interval and follow the FIFO
order. Denoted by Ĝl the set of refined tasks in the group
Pl . By thel competitiveness of FFS, we have F F S(Ĝl ) =
G is assumed to be the minimum one between di − ri and a
0<t≤T ŝ (t) ≤ 2OP T (Ĝl ) for 0 ≤ l ≤ blog Lc. In
the extension process, the lengthes of blocks generated in
F F S(Ĝl ) are enlarged at most twice so as to satisfy the
8 VOLUME 4, 2016
1: refine interval of each task Ji to be (r̂i , dˆi ] = (ri , ri +
2blog(di −ri )c ].
2: the workload requirement of Ji is modified to be p̂i =
min{pi , dˆi − r̂i }
3: let the tasks with the same refined length of 2l form the
same group Gl .
4: run online Algorithm FFS over tasks in Gl , which will
call LAF to output the active blocks and determine the
function ŝl (t) at time t.
5: for each block that is generated by LAF, extend it by
enlarging the end time of the block and doubling the
length of the block; the resulting schedule is denoted as
sl (t).
6: determine the schedule at time t to be s(t) =
max0≤l≤blog Lc sl (t).
P l
workload of the original tasks. That is, 0<t≤T s (t) ≤
l
2ŝ (t). Furthermore, there are blog Lc + 1 such groups.
Combining these Presults, we have
ADS(J) = 0<t≤T max0≤l≤blog Lc sl (t)
≤ 0≤l≤blog Lc 0<t≤T sl (t)
P P
≤ 0≤l≤blog Lc 0<t≤T 2ŝl (t)
P P
P
≤ 0≤l≤blog Lc 2 · 2OP T (Ĝl )
≤ 4(blog Lc + 1)OP T (J)
where the last inequality holds by OP T (J) ≥ OP T (Gl ) ≥
OP T (Ĝl ). Therefore, online algorithm ADS achieves a com-
petitive ratio of 4(blog Lc + 1).
VI. SIMULATION RESULTS
Our theoretical analysis has bounded the worst-case perfor-
mance of the online algorithms. In this section, we perform
simulations to further validate their average performances.
In the simulation, we will compare our online algorithms
with the optimal offline solution and two baselines, which are
listed as follows.
• OPT, which is the optimal offline solution.
• Earliest-First, which is a greedy schedule that greedily
starts the execution of the tasks on their arrivals.
• Latest-Schedule, which is a schedule that postpones the
execution of the tasks to the latest possible time.
The default setting of the simulations is as follows. Task
arrival time ri is assumed to be a random integer that follows
uniform distribution U (1, 500). Arrival time points are sorted
so that r1 ≤ r2 ≤ . . . ≤ rn . For each arrival time ri , the
deadline is generated by randomly selecting an integer in
(ri , ri + L] where L is set to be 100. All deadlines are sorted
so that an earlier arrived task carries an earlier deadline,
d1 ≤ d2 ≤ . . . ≤ dn . The workload requested in each task
random variable following uniform distribution U (1, 30). By
default, the number of tasks is set to be 50. The maximum
length of the time duration L and the mean value of the

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

(a) (a)

(b) (b)

(c) (c)

FIGURE 5: Comparison between FFS, DP, EF and LS in FIGURE 6: Comparison between ADS, EF and LS in AD
FIFO task model when: (a) number of tasks changes; (b) task model when: (a) number of tasks changes; (b) maximum
maximum length of the time duration of tasks changes; (c) length of the time duration of the tasks changes; (c) mean
mean value of the workload requested in tasks changes. value of the workload requested in tasks changes.

workload requested in tasks are set to be 100 and 15 if not
specified, respectively.
We first perform simulations to evaluate our algorithm
FFS for FIFO task model. Fig. 5 shows the simulation results
of algorithm FFS. Each point in these figures is a mean value
of 1000 random instances. We first evaluate the performance
when the number of tasks increases from 10 to 100 with
a step of 10. As it is shown in Fig. 5(a), the total sensing
time of different algorithms increases as the number of tasks
increases. The total sensing time of our online algorithm is
much less than those of algorithms EF and LS. Moreover,
the total sensing time is no more than two times of the
optimal offline solution, which is consistent to our theoretical
analysis.
Then, we examine their performance when the maximum
length of the time duration of tasks changes. Fig. 5(b) shows
the simulation results. When the maximum time duration
VOLUME 4, 2016
increases, the total sensing time of our online algorithm FFS
is less than those of algorithms EF and LS. Moreover, the
total sensing time is close to the optimal solution.
We further examine the effect of the average value of
workload requested by tasks. As shown in Fig. 5(c), when
the mean value of the workload changes, the total sensing
time of our online algorithm FFS is less than that of EF and
LS. The difference between FFS and EF (or LS) becomes
minor when the average value of workload is too large, which
is because nearly all available time needs to be allocated as
sensing time. In such case, the gap between our algorithm
FFS and the optimal solution is quite small.
Next, we evaluate our algorithm ADS for AD task model.
The setting is the same as above, except that tasks are al-
lowed to have arbitrary deadlines. We compare our algorithm
with the two algorithms EF and LS. Note that we have not
compared it with the optimal solution as no optimal solutions
9

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

are known in the literature. Fig. 6 presents the simulation sensing systems. IEEE Journal on Selected Areas in Communications,
results. We can see from the figures that the trends of different 34(12):4048–4062, 2016.
[16] Mingjun Xiao, Jie Wu, He Huang, Liusheng Huang, and Chang Hu.
schedules remain unchanged, and our online algorithm ADS Deadline-sensitive user recruitment for mobile crowdsensing with prob-
outperforms the two algorithms EF and LS in all simulations. abilistic collaboration. In Network Protocols (ICNP), 2016 IEEE 24th
Therefore, the simulation results above validate the effi- International Conference on, pages 1–10. IEEE, 2016.
[17] Murtaza A Zafer and Eytan Modiano. A calculus approach to energy-
ciency of our online algorithms. efficient data transmission with quality-of-service constraints. IEEE/ACM
Transactions on Networking (TON), 17(3):898–911, 2009.
[18] Andrea Zanella, Nicola Bui, Angelo Castellani, Lorenzo Vangelista, and
VII. CONCLUSION
Michele Zorzi. Internet of things for smart cities. IEEE Internet of Things
In this paper, we investigate a data sharing problem to journal, 1(1):22–32, 2014.
minimize the sensing time in collaborate internet of things. [19] Qingwen Zhao, Yanmin Zhu, Hongzi Zhu, Jian Cao, Guangtao Xue, and
Bo Li. Fair energy-efficient sensing task allocation in participatory sensing
We develop algorithms with performance guarantees in the with smartphones. In INFOCOM, 2014 Proceedings IEEE, pages 1366–
offline and online scenarios, respectively. For FIFO tasks, 1374. IEEE, 2014.
we present an O(n3 ) optimal algorithm and a 2-competitive [20] Yawei Zhao, Deke Guo, Jia Xu, Pin Lv, Tao Chen, and Jianping Yin. Cats:
Cooperative allocation of tasks and scheduling of sampling intervals for
online algorithm. For AD tasks, we provide a logarithmic maximizing data sharing in wsns. ACM Transactions on Sensor Networks
competitive online algorithm. The proposed algorithms are (TOSN), 12(4):29, 2016.
validated to be efficient in reducing the overhead of sensing. [21] Chunsheng Zhu, Victor C. M. Leung, Kun Wang, Laurence T. Yang, and
Yan Zhang. Multi-method data delivery for green sensor-cloud. IEEE
In the future work, it is interesting to investigate the issue of Communications Magazine, 55(5):176–182, 2017.
load balancing over multiple sensors. [22] Chunsheng Zhu, Victor CM Leung, Laurence T Yang, and Lei Shu. Col-
laborative location-based sleep scheduling for wireless sensor networks
integratedwith mobile cloud computing. IEEE Transactions on Computers,
REFERENCES 64(7):1844–1856, 2015.
[1] Luigi Atzori, Antonio Iera, and Giacomo Morabito. The internet of things: [23] Chunsheng Zhu, Joel J. P. C. Rodrigues, Victor C. M. Leung, Lei Shu, and
A survey. Computer networks, 54(15):2787–2805, 2010. Laurence T. Yang. Trust-based communication for the industrial internet
[2] Allan Borodin and Ran El-Yaniv. Online computation and competitive of things. IEEE Communications Magazine, 56(2):16–22, 2018.
analysis. cambridge university press, 2005. [24] Chunsheng Zhu, Huan Zhou, Victor C. M. Leung, Kun Wang, Yan Zhang,
[3] Wanshi Chen, Michael J Neely, and Urbashi Mitra. Energy-efficient and Laurence T. Yang. Toward big data in green city. IEEE Communica-
transmissions with individual packet delay constraints. IEEE Transactions tions Magazine, 55(11):14–18, 2017.
on Information Theory, 54(5):2090–2109, 2008.
[4] Yuanfang Chen, Gyu Myoung Lee, Lei Shu, and Noel Crespi. Industrial
internet of things-based collaborative sensing intelligence: framework and
research challenges. Sensors, 16(2):215, 2016.
[5] Xiaolin Fang, Hong Gao, Jianzhong Li, and Yingshu Li. Application-
aware data collection in wireless sensor networks. In INFOCOM, 2013
Proceedings IEEE, pages 1645–1653. IEEE, 2013.
[6] Zhenni Feng, Yanmin Zhu, Qian Zhang, Lionel M Ni, and Athanasios V
Vasilakos. Trac: Truthful auction for location-aware collaborative sensing
in mobile crowdsourcing. In INFOCOM, 2014 Proceedings IEEE, pages
1231–1239. IEEE, 2014.
[7] Raghu K Ganti, Fan Ye, and Hui Lei. Mobile crowdsensing: current state
and future challenges. IEEE Communications Magazine, 49(11), 2011.
[8] William I Grosky, Aman Kansal, Suman Nath, Jie Liu, and Feng Zhao.
Senseweb: An infrastructure for shared sensing. IEEE multimedia, 14(4),
2007.
[9] Byung Mun Lee and Jinsong Ouyang. Intelligent healthcare service by
using collaborations between iot personal health devices. blood pressure,
10(11), 2014.
[10] Wei-Hsun Lee, Shian-Shyong Tseng, and Wern-Yarng Shieh. Collabo-
rative real-time traffic information generation and sharing framework for
the intelligent transportation system. Information Sciences, 180(1):62–70,
2010.
[11] Victor Shnayder, Mark Hempstead, Bor-rong Chen, Geoff Werner Allen,
and Matt Welsh. Simulating the power consumption of large-scale sensor
network applications. In Proceedings of the 2nd international conference
on Embedded networked sensor systems, pages 188–200. ACM, 2004.
[12] Arsalan Tavakoli, Aman Kansal, and Suman Nath. On-line sensing task
optimization for shared sensors. In Proceedings of the 9th ACM/IEEE
International Conference on Information Processing in Sensor Networks,
pages 47–57. ACM, 2010.
[13] Niki Trigoni, Yong Yao, Alan Demers, Johannes Gehrke, and Rajmohan
Rajaraman. Multi-query optimization for sensor networks. In International
Conference on Distributed Computing in Sensor Systems, pages 307–321.
Springer, 2005.
[14] Weiwei Wu, Jianping Wang, Minming Li, Kai Liu, and Junzhou Luo.
Energy-efficient transmission with data sharing. In Computer Commu-
nications (INFOCOM), 2015 IEEE Conference on, pages 73–81. IEEE,
2015.
[15] Weiwei Wu, Jianping Wang, Minming Li, Kai Liu, Feng Shan, and Jun-
zhou Luo. Energy-efficient transmission with data sharing in participatory

10 VOLUME 4, 2016

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.
 This article has been accepted for publication in a future issue of this journal, but has not been fully edited. Content may change prior to final publication. Citation information: DOI
10.1109/ACCESS.2018.2859357, IEEE Access

Author et al.: Preparation of Papers for IEEE TRANSACTIONS and JOURNALS

WEIWEI WU is an associate professor in South-

east University, P.R. China. He received his BSc
degree in South China University of Technology
and the PhD degree from City University of Hong
Kong (CityU, Dept. of Computer Science) and
University of Science and Technology of China
(USTC) in 2011, and went to Nanyang Techno-
logical University (NTU, Mathematical Division,
Singapore) for post-doctorial research in 2012. His
research interests include optimizations and algo-
rithm analysis, wireless communications, crowdsourcing, cloud computing,
reinforcement learning, game theory and network economics.

XIANGPING (BRYCE) ZHAI received the

B.Eng. degree in Computer Science and Tech-
nology from Shandong University in 2006, and
the Ph.D. degree in Computer Science from City
University of Hong Kong in 2013.
He is currently an Assistant Professor of the
College of Computer Science and Technology,
Nanjing University of Aeronautics and Astronau-
tics, China. Previously, he was a Postdoctoral Fel-
low at the City University of Hong Kong. His
research interests are in the area of Internet of Things, power control, edge
computing, resource optimization and spatial analytics. He has been actively
involved in organizing and chairing sessions, and has served as reviewer for
several journals and TPC for several international conferences.

YINGCHAO ZHAO received the B.E. and Ph.D.

degrees from the Department of Computer Sci-
ence and Technology, Tsinghua University, Bei-
jing, China, in 2004 and 2009, respectively. She
is currently an Assistant Professor with the School
of Computing and Information Sciences, Caritas
Institute of Higher Education, Hong Kong. Her
current research interests include algorithm de-
signs, scheduling, and embedded systems.

VOLUME 4, 2016 11

2169-3536 (c) 2018 IEEE. Translations and content mining are permitted for academic research only. Personal use is also permitted, but republication/redistribution requires IEEE permission. See
http://www.ieee.org/publications_standards/publications/rights/index.html for more information.