Distributed Continuous Range-Skyline Query Monitoring over the Internet of Mobile Things

TL;DR

This paper introduces a distributed, non-centralized method for efficiently monitoring continuous range-skyline queries in mobile environments, optimizing performance by predicting object movements and reducing unnecessary computations.

Contribution

It proposes the DCRSQ process, a novel approach that improves efficiency and scalability for range-skyline queries in IoMT by considering object mobility and prediction.

Findings

DCRSQ outperforms existing methods in various scenarios.

The approach reduces computation overhead by predicting object movements.

Extensive simulations validate the effectiveness of DCRSQ.

Abstract

A Range-Skyline Query (RSQ) is the combination of range query and skyline query. It is one of the practical query types in multi-criteria decision services, which may include the spatial and non-spatial information as well as make the resulting information more useful than skyline search when the location is concerned. Furthermore, Continuous Range-Skyline Query (CRSQ) is an extension of Range-Skyline Query (RSQ) that the system continuously reports the skyline results to a query within a given search range. This work focuses on the RSQ and CRSQ within a specific range on Internet of Mobile Things (IoMT) applications. Many server-client approaches for CRSQ have been proposed but are sensitive to the number of moving objects. We propose an effective and non-centralized approach, Distributed Continuous Range-Skyline Query process (DCRSQ process), for supporting RSQ and CRSQ in mobile environments. By considering the mobility, the proposed approach can predict the time when an object falls in the query range and ignore more irrelevant information when deriving the results, thus saving the computation overhead. The proposed approach, DCRSQ process, is analyzed on cost and validated with extensive simulated experiments. The results show that DCRSQ process outperforms the existing approaches in different scenarios and aspects.

Tables

Table 1. TABLE I: Comparisons of Existing Works for Skyline Query

	Methods
Considered Issues	BBS [7]	LDSQ [17]	PadSkyline [18]	EDDS [19]	RSQ [5]	L-SQ [20]	DRSQ & DCRSQ
Distributed Databases	×	×	✓	✓	×	✓	✓
Distributed Computing	×	×	✓	✓	×	✓	✓
Moving Objects	×	×	×	×	✓	×	✓
Moving Queries	×	×	×	×	✓	✓	✓
Non-Index based	×	×	×	×	✓	×	✓

Table 2. TABLE II: Important Notations

Notation	Description
$𝒜$	The sensing area
$S$	The set of all the mobile nodes
$s$	Sensor node (mobile object)
$q$	Query node
$R$	Query range
$r$	Transmission range (Sensing range)
$N$	Number of mobile sensor nodes
$N_R$	Number of mobile sensor nodes in the query range
$N_r$	Number of neighbors in the transmission range
$\Delta t$	A period of time for monitoring a CRSQ
$T$	A time interval for each sensor node return its information periodically
$T_{safe}$	A predicted time period that the answer may change
$t_{M_s}$	The monitoring time of node $s$ w.r.t. $q$
$m_q$	Query message
$m_r$	Reply message
$TTL$	Time-To-Live (Hop count) of a message
$dist$	Euclidean distance

Table 3. TABLE III: Simulation Parameters for Scenario I

Parameter	Default Value	Range (type)
Sensing Area ($m\times m$)	400 $\times$ 400	–
Number of Sensor Nodes	100	50, 100, 150 ,200
Number of Queries	1	1, 2, 3, 4, 5
Query Range, $R$ ($m$)	80	60, 80, 100, 120
Transmission Range, $r$ ($m$)	75	50, 75, 100, 125
Node Speed ($m/s$)	2	1, 2, 3, 4, 5
$TTL$ of Messages (centralized approach)	5	–
Bandwidth ($Mb/s$)	2	–

Table 4. TABLE IV: Simulation Parameters for Scenario II

Parameter	Default Value	Range (type)
Sensing Area ($m\times m$)	500 $\times$ 500	–
Simulation time (seconds)	60	–
Number of Sensor Nodes	60	30, 60, 90, 120
Number of Queries	1	1 to 10
Query Range, $R$ ($m$)	100	50, 100, 150, 200
$\Delta t$ of a Query (seconds)	10	–
Transmission Range, $r$ ($m$)	75	50, 75, 100, 125
Maximum of Node Speed ($m/s$)	10	5, 10, 15, 20, 25, 30
$TTL$ of Messages (centralized approach)	5	–
Bandwidth ($Mb/s$)	2	–

Equations

$$R^2$$

$$E[q_{spread}]=\sum _{i=1}^k{N}_r^i\prod _{j=1}^i{P}_j,$$

$$E_{centralized}[q_{response}]=\sum _{i=1}^k{N}_r^i\times i\prod _{j=1}^i{P}_j,$$

$$E_{centralized}[q]=E[q_{spread}]+E_{centralized}[q_{response}].$$

$$E_{DRSQ}[q_{response}]=\sum _{i=1}^k{N}_r^i(\ln N_r^i{)}^{d-1}{P}_{k-i},$$

$$E_{DRSQ}[q]=E[q_{spread}]+E_{DRSQ}[q_{response}].$$

$$E_{centralized}^{CRSQ}[q]=\frac{|\Delta t|}{T}\times E_{centralized}[q],$$

$$E_{DCRSQ}^{CRSQ}[q]=E[q_{spread}]+\frac{|\Delta t|}{\overline{T_{safe}}}\times E_{DRSQ}[q_{response}],$$

Full text

I Introduction

In recent years, skyline queries receive much attention in various applications such as multi-preference analysis and decision making. In such applications, a skyline set contains the most interesting objects or best objects and retrieves the objects that are not dominated by any other objects. In database systems, queries specialized to search for the non-dominated data objects are called skyline queries and their corresponding result sets are known as skyline sets. The data objects in a skyline set are known as skyline objects. In tradition, the skyline query is discussed in a static environment, where all the data objects and query are static. Now it is progressively extended for dynamic or distributed environments. If the user is moving or the query is issued from a dynamic environment, such a case addresses the skyline problem in dynamic environments. The skyline query is also used in spatial networks and all the considered data objects are highly distributed. Thus, how to process skyline queries in distributed environments has become an important issue.

Conventional Location-Based Services (LBSs) focus on processing proximity-based queries, including range query [1, 2] and nearest neighbor (NN) query [3, 4]. However, these queries are not sufficient for providing high-quality services to mobile users without considering both spatial and non-spatial information simultaneously. A typical scenario is finding a nearby hotel with a cheap price, in which the distance is a spatial attribute and the price is non-spatial. Clearly, in this case, a multi-criteria query is more appealing than a conventional spatial query that considers the distance only. Among various multi-criteria queries, the skyline query is considered as one of the most classical ones and receives a great deal of attention in LBS research. However, the resulting skyline may contain many useless data objects since the resulting data objects (hotels) may be too far away from the query (user). Some other works [5, 6] tend to solve the range-skyline query to improve the QoS of LBSs by considering the dynamic data objects and supporting the continuous range-skyline query. The continuous range-skyline is a collection of range-skyline answers during a specific time interval that the query concerns. Such a query is applied in many LBSs whose environments are dynamic. For example, searching taxis is an application of the continuous range-skyline query. Users can use such a service to obtain some candidate taxis which are nearby, cheap, and high-ranked. Hence, this work focuses on processing the range-skyline query and the continuous case.

Most of the existing approaches [5, 6, 7, 8] process the skyline or range-skyline in a centralized way under the assumption that data objects are stored in a centralized fashion. They provide some algorithms that focus on how to index the spatial or non-spatial data and how to efficiently process queries with a large number of data objects. Although some of them have discussed spatial queries and moving data objects in the distributed and mobile environments like the Internet of Mobile Things (IoMT) or Mobile Wireless Sensor Networks (MWSNs), the computing model is still centralized. The collected data objects are stored distributively and the process of data sensing (collection) phase is not discussed. They discussed the changes (or updates) of data and treated such cases as moving data objects. In these approaches, each mobile node needs to continuously obtain the location information of itself by GPS and sends the information back to the server(s) for updating the database(s). However, the overhead of the data collection process was not mentioned and addressed. If we use the conventional methods in a specific scenario, the position of each data object changes frequently, the server(s) will receive a huge amount of information for updating the location of each data object in a short time. In this case, the system will be overloaded. Furthermore, a large number of messages for updates will occupy quite a lot of communication bandwidth.

In general, the IoMT applications based on MWSNs are self-configuring and infrastructure-less. IoMT consists of many mobile sensor nodes connected by wireless communication. In such environments, each node can move freely and independently in any direction, so the communication links between nodes will change frequently. Each node can forward the information unrelated to its owns and act as a router. In comparison with the client-server environment, IoMT applications may have no centralized server to handle the spatial queries. Accordingly, the information system for an infrastructure-less IoMT application must process queries in a distributed (or decentralized) way. Each mobile sensor node can cooperate and exchange data with each other and then derive the answers for spatial queries. Since most of the existing works consider multiple data sources but only a few works consider the fully distributed and dynamic computing environments, one of the main objectives of this work is to provide a fully distributed approach for processing Range-Skyline Queries (RSQ) and Continuous Range-Skyline Queries (CRSQ) in an infrastructure-less mobile environments, IoMT.

In this work, we propose a Distributed Range-Skyline Query process (DRSQ process) in IoMT whose computing model is decentralized. We further extend DRSQ to Distributed Continuous Range-Skyline Query process (DCRSQ process) for supporting continuous range-skyline query processing. Each mobile node can filter out the irrelevant data objects, derive a primary candidate answer set of the received query, and then report the candidate set to the query node. For validating the DRSQ process, we perform the simulation experiments with the following measurements: the response time and the number of messages (I/O operations). Furthermore, to validate the DCRSQ process, we consider four measurements: the number of accessed objects (the overhead on the query node), the number of messages, precision and recall. We also consider the effects on the number of sensor nodes, the number of queries, the transmission range of a node, and the query range in the DRSQ process. One additional effect, node speed, is considered in the DCRSQ process. Besides, we give the analysis on network cost for the proposed approach and compare the proposed approach with the centralized approach. As the results show, the proposed approach has a better performance in the simulation.

We address the distributed continuous range-skyline query (DCRSQ) processing over the IoMT and make the following contributions:

• •

We propose a distributed approach, DCRSQ, to make the process of range-skyline query appropriate to the Internet of Mobile Things environments.

• •

To the best of our knowledge, this is the first study for this problem simultaneously considering the computing process and information filtering in the data collection phase so that the performance of system is significantly improved in comparison with the conventional approach.

• •

With the mobility, DCRSQ can make each node predict the time when its neighboring mobile data objects fall in the query range and avoid periodically flooding messages for updating the information of neighbors.

• •

We give a formal analysis of the network cost on the proposed approach and conduct extensive simulations to evaluate the performance. The simulation results show that DCRSQ can save more than 15$\%$ network cost and achieve almost 90$\%$ accuracy in most of the scenarios.

The balance of this paper is organized as follows. In Section II, we introduce the background and review related research. Section III presents the overview of problem and the notations used in this work. Section IV introduces the proposed solution and a breakdown of the data structures and algorithms. Some analysis on network cost will be discussed in Section V. Simulation experiments are presented in Section VI. Finally, we make concluding remarks in Section VII.

II Related Work

The IoMT has triggered a lot of emerging applications and services [9, 10] in wireless communications, fog/edge computing, and (mobile) big sensor data processing. Ang et al. [9] identified some important research topics, like data analysis and processing, in smart city ecosystems which base on IoMT. They also investigate some use cases in IoMT (smart cities) such as real-time urban monitoring [11] and spatial decision support system for flood risk management [12]. These use cases are spatio-temporal applications classified in [10]. In spatio-temporal IoMT applications, spatial query processing plays a key role for the decision making. In our work, we focus on the range-skyline query for this kind of IoMT applications.

A range-skyline query is an extension of skyline query with a distance threshold in spatial databases. Borzsony et al. [13] introduced skyline operator into the database systems with algorithms Block Nested Loop (BNL) and Divide-and-Conquer (D&C). A great number of researchers also keep their eyes on skyline query processing from then on. Papadias et al. [7] proposed a Branch-and-Bound Skyline (BBS) method based on the best-first nearest neighbor algorithm [14]. Cheema et al. [15] proposed a safe zone based approach and combined it with Vonronoi cells to provide a better BBS algorithm for processing skyline queries. Hose and Vlachou [16] provided comprehensive analysis of previous skyline algorithms without indexing supports, and proposed a new hybrid method with improvement. Lin et al. [5] also discussed both the indexing and non-indexing algorithms, and then extended their work to process probabilistic RSQ. All these works discuss the issues in a centralized data storage.

To make the applications scalable and improve the performance of skyline query processing, many parallel or distributed algorithms have been proposed. Wu et al. [21] first attempted a progressive processing of skyline queries on a CAN-based P2P network [22]. By using the query range to recursively partition the data region involved and encoding each involved sub-region dynamically, their method can progressively report skyline objects without accessing the data sites not containing potential skyline objects, thus saving computation overhead. Chen et al. [18] proposed a parallel approach to filter data objects efficiently from distributed databases for processing constrained (or range) skyline queries. Zheng et al. [17] introduced a variant notion of the valid scope for skyline queries, that can save the re-computation if the next query is still inside the valid scope. Although the above existing works considered the distributed databases, they still used some high-performance servers to process skyline queries with the data objects from multiple data sources. Alternatively, we consider an infrastructure-less environment, IoMT, in this work.

Huang et al. [20] proposed techniques for skyline query processing in MANETs. Lightweight devices in MANETs are able to issue spatially constrained skyline queries that involve data stored on many mobile devices. Queries are forwarded through the whole MANET without routing information. However, they only considered the mobile distributed data sites over MANETs but did not consider the moving objects. Ahmed et al. [19] proposed an approach, Enhanced Distributed Dynamic Skyline (EDDS), to handle skyline queries over the IoMT. EDDS used disc track and sector to map the data locations. Such a way improves the performance of searching the new input data objects for computing and updating the skyline. Although EDDS considered the dynamically data input from the distributed sensor nodes, EDDS did not consider the mobile sensor nodes (moving objects).

In fact, the conventional works can be categorized into following models: (1) single data source with a centralized computing model, (2) multiple data sources with a centralized computing model, and (3) multiple data sources with a distributed/decentralized computing model. The third model is more popular in recent years. However, it is not easy to compare all the works in type (3) by simulation or experiments since the considered environments, assumptions, and requirements are quite different. To the best of our knowledge, most of works in type (3) consider the distributed computing model with multiple ”powerful” computing servers for the query processing. Only very few works consider query processing over a lightweight mobile environment whose computing resource is limited. However, these few works only consider the static spatial data and do not support moving data objects. We therefore present a comparison summary of the existing methods related to skyline query and our work in Table I.

III Preliminaries

In this section we give some preliminaries of the problem, including some fundamental notations and definitions. We consider a data set $S$ of sensor nodes. Each mobile sensor node $s\in S$ is associated with a spatial (i.e., location or distance) attributes and several other non-spatial attributes (e.g., temperature, trust rank, and possibility). Note that we use Euclidean distance in the spatial attribute and the non-spatial dominance relation between the mobile objects is described as Definition 1.

Definition 1** (Non-spatial Dominance).**

Given two sensor nodes $s$ and $s^{\prime}$, if $s^{\prime}$ is no worse than $s$ in all non-spatial attributes, then we say $s^{\prime}$ non-spatially dominates $s$. We say that $s^{\prime}$ is a non-spatial dominator object of $s$, and $s$ is a non-spatial dominance object of $s^{\prime}$. Formally, it is denoted as $s^{\prime}\triangleleft s$. The set of $s$’s non-spatial dominator objects is denoted as $Dom(s)$, i.e., $s$ is dominated by any object in $Dom(s)$ on non-spatial attributes.

If $s^{\prime}\triangleleft s$ and $s\triangleleft s^{\prime}$ are hold, it means that non-spatial attributes of $s^{\prime}$ and $s$ are equivalent. In this case, the system is going to check the dominance relation between the spatial attributes of $s^{\prime}$ and $s$. So the complete dominance relation can be described as

Definition 2**.**

**(Dominance)

Given a query node $q$ and two sensor nodes $s$ and $s^{\prime}$, if 1) $s^{\prime}$ non-spatially dominates $s$, and 2) $dist(q,s^{\prime})\leq dist(q,s)$ (i.e., $s^{\prime}$ also spatially dominates $s$), then we say $s^{\prime}$ dominates $s$ w.r.t. the query node $q$. Formally, it is denoted as $s^{\prime}\triangleleft_{q}s$.**

Note that if $s^{\prime}\triangleleft_{q}s$ and $s^{\prime}\triangleleft_{q}s$, it means that both spatial and non-spatial attributes of $s^{\prime}$ and $s$ are equivalent with respect to the query node $q$.

With the above definitions, point-skyline query (PSQ) can be defined as

Definition 3**.**

**(Point-Skyline Query (PSQ))

Given a data set $S$, the skyline of a query node $q$ is a subset of $S$ in which each object (sensor node) is not dominated by any other object in $S$ w.r.t. $q$. We call this subset skyline set and denote it as $PSQ(S,q)=\{s|s\in S\wedge\forall s^{\prime}\in S-\{s\}:s^{\prime}\ntriangleleft_{q}s\}$.**

In accordance with the above definitions, the range-skyline query can be defined in Definition 4 and such a definition comes from a global view of system.

Definition 4**.**

**(Range-Skyline Query (RSQ))

Given a data set $S$ with a range $R$, the range-skyline query with respect to $q$ returns the skyline set of the subset of objects (sensor nodes) that locate in $R$. Formally, it is denoted as $RSQ(R,S,q)$, and $RSQ(R,S,q)=\{s\in S\wedge s$ locates in $R|\forall s^{\prime}\in S-\{s\}\wedge s^{\prime}$ locates in $R:s^{\prime}\ntriangleleft_{q}s\}$.**

Fig. 1 is an example of a range-skyline w.r.t. query node $q$, where the mobile user wants to search a nearby taxi around the query node with a high rank of service quality. The system firstly uses $q$’s range value, $R$, to prune the irrelevant moving objects which are out of the range. Then the system examines dominance relations between the remaining data objects. We assume that the mobile objects with smaller weights have a higher priority in this example. Since $s_{1}$ is the nearest neighbor of $q$ and spatially dominates all the other sensor nodes, $s_{1}$ must be in the resulting range skyline. Sensor node $s_{4}$ non-spatially dominates the other nodes in the range $R$, except $s_{3}$ and $s_{5}$. So the possible RSQ is $\{s_{1},s_{3},s_{4},s_{5}\}$. However, $s_{3}$ is dominated by $s_{5}$ in the non-spatially attribute. Thus, $RSQ(R,S,q)$ will be $\{s_{1},s_{4},s_{5}\}$. It means that the system returns taxi $s_{1}$, $s_{4}$ and $s_{5}$ to the mobile user.

A continuous range-skyline query (CRSQ) is an extension of RSQ. CRSQ will monitor the environmental information within a given range and continuously produce the skyline for a period of time. It means that the system monitors each continuous range-skyline query $q$ within a specific range $R$ for a time period $\varDelta t=[t_{0},t_{end}]$. Since each sensor node can move in the considered environment, such a phenomenon will make the answer of an RSQ change during the monitoring time $\varDelta t$. We formally define the continuous range-skyline query as below.

Definition 5**.**

**(Continuous Range-Skyline Query (CRSQ))

Suppose that the notations are defined as above. Given a query $q$ with a query range $R$ and a time period $\varDelta t=[t_{0},t_{end}]$, the continuous range-skyline query returns a collection of range-skyline sets $RSQ_{t_{i}}(R,S,q)$, where $t_{i}\in\varDelta t$ and $i$ is the number of updated results. Formally, it is denoted as $CRSQ(R,S,q,\varDelta t)=\{RSQ_{t_{i}}(R,S,q)|t_{i}\in\varDelta t,i\in N\}$.**

An example of a continuous range-skyline query $q$ is shown in Fig. 2. In this example, the system monitors the range-skyline of $q$ for a time period $\varDelta t$ and the result may be a collection of answers that contains different RSQ answers at different time since the answer may change. The answer collection contains 3 RSQ results at time $t_{0}$, $t_{1}$, and $t_{2}$ and these results are respectively shown in Fig. 2(a), Fig. 2(b), and Fig. 2(c). The result of $q$ is $CRSQ(R,S,q,\varDelta t)=\{RSQ_{t_{0}}(R,S,q),RSQ_{t_{1}}(R,S,q),RSQ_{t_{2}}(R,S,q)\}$, where $RSQ_{t_{0}}(R,S,q)=\{s_{1},s_{4},s_{5}\}$, $RSQ_{t_{1}}(R,S,q)=\{s_{1},s_{8},s_{11}\}$, and $RSQ_{t_{2}}(R,S,q)=\{s_{8}\}$. The final output therefore will be $\{<\{s_{1},s_{4},s_{5}\},[t_{0},t_{1})>,<\{s_{1},s_{8},s_{11}\},[t_{1},t_{2})>,<\{s_{8}\},[t_{2},t_{end}]>\}$.

IV The Distributed Continuous Range-Skyline Query Process

This section describes in detail the proposed distributed range-skyline query process over the IoMT. The proposed approach includes two parts: distributed range-skyline query process (DRSQ process) and distributed continuous range-skyline query process (DCRSQ process). The fundamental distributed approach for processing snapshot RSQs will be introduced in the DRSQ process. In second part, the DCRSQ process is extended from the DRSQ process with the consideration of node mobility to support CRSQ. Thus, the system can predict the change of RSQ result when monitoring a CRSQ during a period of time in IoMT environments.

IV-A Distributed Range-Skyline Query

In general, the query processing in mobile and distributed environments like IoMT based on MWSNs or MANETS, contains three steps. The first step is the local process that computes the skyline set based on local data and filters information received along with the query. The second step is query routing by which the query message can be forwarded to some of the neighboring nodes in order to retrieve their partial results. Thus, the node decides whether a neighbor can contribute to the skyline set based on available routing information. The last step is to merge the results, where the node receives the local result sets from queried neighbors and merges all the partial results by checking for dominated objects. Then, each node sends the merged result to the query node hop by hop.

IV-A1 Description of DRSQ

We assume that each mobile sensor node can hold a small database to store the collected sensing data and the query’s information for the distributed query process. The collected sensing data set is called local data set and all of the data are collected from the sensor node’s one-hop neighbors and itself. Hence, each mobile sensor node can derive the result of local range-skyline query process (LRSQ process) which may be the subset of range-skyline and return the result to the query node for computing the final (global) range-skyline answer. The result of LRSQ is defined in Definition 6.

Definition 6**.**

**(Local Range-Skyline Query)

Suppose that the notations are defined as above and a query node $q$ with a query range $R$ is given. After a mobile sensor node $s_{j}$ receives the query $q$, $s_{j}$ will return a subset of the local data set $S_{s_{j}}$ and each object $s$ in $S_{s_{j}}$ is $s_{j}$’s neighbor and not dominated by any other object $s^{\prime}$ in $S_{s_{j}}$ w.r.t. $q$, where $S_{s_{j}}\subseteq S$. We refer to this result as a local range-skyline set and denote it as $LRSQ_{s_{j}}(R,S,q)=\{s$ locates in $R\wedge s\in S_{s_{j}}|\forall s^{\prime}\in S_{s_{j}}-\{s\}\wedge s^{\prime}$ locates in $R:s^{\prime}\ntriangleleft_{q}s\}$.**

According to Definition 6, the query node $q$ will receive the results of $LRSQ_{s_{j}}(R,S,q)$, where $s_{j}$ is $q$’s one-hop neighbor ($1\leq j\leq k$) and $k$ is the maximum number of neighbors. Then the query node takes the union of these results as the candidate set, $RSQ_{candidate}=\bigcup^{k}_{j=1}{LRSQ_{s_{j}}(R,S,q)}$. After $RSQ_{candidate}$ is derived, the query node will use Definition 1 and Definition 2 to examine the dominance relations of all the mobile objects in $RSQ_{candidate}$ again and then save the final result in $RSQ_{distributed}$ set. Such a cooperative and distributed process is refer to distributed range-skyline query process (DRSQ process). As a result, DRSQ can be defined as Definition 7.

Definition 7**.**

**(Distributed Range-Skyline Query)

Suppose the candidate set $RSQ_{candidate}$ of query node $q$ has been computed. Then, the query node $q$ uses $RSQ_{candidate}$ to derive the skyline set of the data objects in $R$ and the result of distributed range-skyline query can be denoted as $DRSQ(R,S,q)=\{s$ locates in $R\wedge s\in RSQ_{candidate}|\forall s^{\prime}\in RSQ_{candidate}-\{s\}\wedge s^{\prime}$ locates in $R:s^{\prime}\ntriangleleft_{q}s\}$.**

The above distributed process for LRSQ derivation has a benefit that many irrelevant data objects are also pruned during the process. Thus, the computation overhead of the query node can be reduced.

IV-A2 Overview of DRSQ process

Before introducing the DRSQ processes on a query node and a sensor node with pseudo-codes in detail, we use a running example in Fig. 3 to depict the overview of DRSQ process and explain it step by step. Note that the spatial and non-spatial attributes of each sensor node (data object) are shown in Fig. 1.

As shown in Fig. 3 and Fig. 3, a query node spreads the query message $m_{q}$ ($TTL=2$) to its one hop and two-hop neighbors. Each message $m_{q}$ contains the information of query node, such as query range $R$, location, and speed of $q$. Fig. 3 then shows that two-hop neighbors of $q$, $s_{2},s_{3},s_{5},$ and $s_{11}$, use their own local information to derive their local range-skyline results and return these local range-skyline results to $q$’s one-hop neighbors, $s_{1}$ and $s_{4}$. After $s_{1}$ and $s_{4}$ receive the local range-skyline results from the two-hop neighbors of $q$, they will merge the received local range-skyline results and do the dominance check with the information of themselves. As Fig. 3 shows, the local skyline candidate sets of $s_{1}$ and $s_{4}$ are $LRSQ_{s_{2}}=\{s_{1},s_{2}\}$ and $LRSQ_{s_{3}}\cup LRSQ_{s_{5}}\cup LRSQ_{s_{11}}=\{s_{3},s_{4},s_{5}\}$ respectively. Sensor nodes $s_{1}$ and $s_{4}$ then check the dominance relations between all the candidate data objects and obtain their local range-skyline results, $LRSQ_{s_{1}}=\{s_{1},s_{2}\}$ and $LRSQ_{s_{4}}=\{s_{4},s_{5}\}$ because of $s_{5}\triangleleft_{q}s_{3}$ respectively, as Fig. 3 shows. After aggregating the local range-skyline sets, $LRSQ_{s_{1}}$ and $LRSQ_{s_{4}}$, $s_{1}$ and $s_{4}$ return them to the query node $q$ respectively.

After receiving the local range-skyline sets from $s_{1}$ and $s_{4}$, query node $q$ merges these sets to derive a candidate set $RSQ_{candidate}=LRSQ_{s_{1}}\cup LRSQ_{s_{4}}=\{s_{1},s_{4},s_{5}\}$. Fig. 3 presents the step of obtaining a candidate set of $q$. Finally, in Fig. 3, query node $q$ checks the dominance relations between all the data objects in local candidate set and derives the final range-skyline, $DRSQ(R,S,q)$ $=\{s_{1},s_{4},s_{5}\}$.

IV-A3 The DRSQ Process

In this subsection, we introduce DRSQ process with pseudo-codes. The whole DRSQ process includes two parts: LRSQ and GRSQ processes. The pseudo-codes of Algorithm 1 and Algorithm 2 respectively show the LRSQ process on a mobile sensor node and the GRSQ process on the query node as well as present the ideas and frameworks of our proposed approaches. Note that each sensor node repeatedly runs the LRSQ process in Algorithm 1 for a query and thus continuously receives messages from the network. When a user (mobile device) issues a query $q$, the device floods query messages to its one-hop neighbors with a maximum hop count, Time-To-Live (TTL). After flooding the query messages, the query node starts GRSQ process (in Algorithm 2) to collect the local skyline sets from its one-hop neighbors and then derives the final result, $RSQ_{distributed}$, for the query.

When each one-hop neighbor of $q$ receives the query messages, it will do the operations from Line 1 to Line 1 of LRSQ process (Algorithm 1). If the TTL value in the received query message is larger than 0, it means that the mobile sensor node is an intermediate node in the routing path of the query and the sensor node will forward the query to its neighbors at Line 1. Otherwise, the mobile sensor node is an end node in the routing path of the query. The sensor node will stop forwarding the query message, add the data objects of itself to the local skyline set $RSQ_{local}$ at Line 1, and then start to return the $RSQ_{local}$ to the query node (at Line 1) through the reversed routing path of the query. Note that $RSQ_{local}$ is equal to the term, $LRSQ_{s{i}}(R,S,q)$, and we may use both interchangeably afterward in this paper.

When an intermediate sensor node receives a response message for the query, it will perform the operations from Line 1 to Line 1 in Algorithm 1 to compute the latest local range-skyline $RSQ_{local}$. Since the received response message contains a local range-skyline set w.r.t. the neighboring node which sent this message, the intermediate mobile sensor node will save the received local range-skyline in a temporary set $RSQ_{neighbor}$. Note that all the data objects in $RSQ_{neighbor}$ do not dominate each other, so the sensor node will check the dominance relations between each data object $o^{\prime}$ in $RSQ_{neighbor}$ and the data object $o$ of itself. If data object $o^{\prime}$ in $RSQ_{neighbor}$ is not dominated by data object $o$, the data object $o^{\prime}$ is still a local range-skyline member. The operations of dominance relation checking are presented from Line 1 to Line 1 of Algorithm 1. The mobile sensor node executes the operation at Line 1 if the data object $o$ of itself is not dominated by any other data objects in $RSQ_{neighbor}$. It indicates that the sensed data object $o$ of the intermediate sensor node becomes one of the local range-skyline member. After the dominance validation, the intermediate sensor node keeps forwarding the response message, including the latest local range-skyline, back to the query node. All the intermediate sensor nodes do the above operations and update the local skyline set which is saved in the response message until the response message is received by the query node.

Algorithm 2 describes the operations executed by the query node $q$ after it floods the query messages. From Line 2 to Line 2, the query node collects all the local range-skyline sets from its one-hop neighbors and merges them into the candidate range-skyline set $RSQ_{candidate}$. Such a union operation is done to avoid recording the same data objects multiple times. Note that the Line 2 is a operation to check whether the received message is a reply message or not. Such a check can avoid the routing loop of a query message. In the considered environment, the query node $q$ is a sensor node and may be an $i$-hop neighbor of a node $s$, so $q$ may receive the query message from $s$ if $TTL>2i-1$, where the appropriate value of $TTL$ will be discussed in Section V. Such a scenario may only occur when the query range $R$ is much larger than the transmission range $r$.

However, $RSQ_{candidate}$ is not the final result for the query because the data objects in all the received local range-skyline sets may dominate each other. So the query node executes the operations from Line 2 to Line 2 for checking the dominance relations between all the candidate points and then saves the non-dominated data objects in a set, $RSQ_{distributed}$. Finally, the query node (the user’s device) returns the final range-skyline, $RSQ_{distributed}$, to the user.

IV-B Distributed Continuous Range-Skyline Query

This subsection is organized as follows. We will first present some important notations and assumptions for the DCRSQ process. Second, we will introduce the proposed DCRSQ approach with a running example extended from the CRSQ example in Fig. 2. Last, the proposed DCRSQ process will be explained in details with some definitions.

IV-B1 System Assumptions

In order to make the DRSQ process able to support CRSQ in the DCRSQ process, some additional and modified assumptions of the system are needed and we will describe them in detail before introducing the DCRSQ process. Details of the system assumptions are given as follows:

• •

Each mobile node can always obtain the spatial (location and mobility) and non-spatial (sensed data) informations of its one-hop neighbors and itself with its GPS equipment. We call such collected informations as local information.

• •

Each mobile node has a limited buffer to store the received CRSQ queries and each stored query will be continuously processed with local information until the query is expired.

• •

Each node also collects the information of existing queries from its neighbors while generating local information of itself.

• •

The size of a network packet (message) is fixed and one packet only can store one data object.

We here show all the important notations used in this paper in Table II.

IV-B2 Overview of DCRSQ

To support CRSQ, the DCRSQ process should take node mobility into account because the movement of nodes may cause frequent change of the answer. We thus adapt the idea of [23], safe-time, for considering the mobility of nodes. The safe time is derived for a node to predict when a neighbor node enters and leaves the query $q$’s range. If a neighboring object leaves the range of $q$, this object will not to a point of range-skyline and thus it will not be processed on the sensor node. It means that the node can determine that processing this neighboring object is necessary or not with the safe-time information.

For deriving the precise safe time, we consider the movement of mobile nodes simultaneously and use Fig. 4 to illustrate. Initially, $dist(q,s)$ is the distance from the query node $q$ to sensor node $s$, where $dist(q,s)\leq R$. In the following, we present the equation to calculate the safe time $t_{|\overline{qs}|}$ when $dist(q,s)=R$. Suppose the initial location of object $q(s)$ is $(x_{q},y_{q})$($(x_{s},y_{s})$) with speed $(v_{x_{q}},v_{y_{q}})$($(v_{x_{s}},v_{y_{s}})$). Since $dist(q,s)=R$, we can have

[TABLE]

After transposing each term, (1) can be a quadratic equation. Then, we can simply use the discriminant of quadratic equation to get two values of the safe time. We select the minimum positive value as the safe time $t_{\overline{qs}}$. Note that the above example shows the case of a leaving node. The other scenario is that a node may enter the range of query $q$. If the node is out of the $q$’s range and receives the query message in advance, the time periods of its entering and leaving can also be obtained by the same way.

For example, a query $q$ issues a CRSQ with $\varDelta t=[3,10]$ at time $t_{0}$. Fig 5 shows the relative locations of $s$ and $q$ at each time step $t_{i}$ where $i\geq 0$. The query $q$ can use (1) to obtain the safe time of node $s$, $t_{\overline{qs}}=[t_{enter},t_{leave}]=[1,6]$. So the exact monitoring time of node $s$ w.r.t $q$, $t_{M_{s}}$, is $[3,6]$, since the $q$ only concerns the results during the time $\varDelta t=[3,10]$ and the node $s$ will leave the range of $q$ after time $t_{6}$.

Combine the prediction of monitoring time with the LRSQ process, the continuous local range-skyline candidate sets also can be obtained. We refer such a process to continuous local range-skyline query process (CLRSQ process). Consider the query $CRSQ(R,S,q,\varDelta t=[0,3])$ in Fig. 2, the nodes $s_{2},s_{3},s_{5},$ and $s_{11}$ in CLRSQ process (modified from the LRSQ process in Fig. 3), respectively return the information of their local range-skyline candidate sets during the time $\varDelta t=[0,3]$. Node $s_{2}$ returns $CLRSQ_{s_{2}}=\{<\{s_{1},s_{2}\},[t_{0},t_{1})>,<\{s_{1},s_{2}\},[t_{1},t_{2})>,<\{s_{2}\},[t_{2},t_{3}]>\}$ back to the intermediate node $s_{1}$. Nodes $s_{3}$, $s_{5}$, and $s_{11}$ respectively return $CLRSQ_{s_{3}}=\{<\{s_{3},s_{4}\},[t_{0},t_{1})>,<\{s_{3},s_{11}\},[t_{1},t_{2})>,<\{s_{3},s_{11}\},[t_{2},t_{3}]>\}$, $CLRSQ_{s_{5}}=\{<\{s_{4},s_{5}\},[t_{0},t_{1})>,<\{s_{4}\},[t_{1},t_{2})>,<\{s_{4}\},[t_{2},t_{3}]>\}$, and $CLRSQ_{s_{11}}=\{<\{s_{3},s_{4}\},[t_{0},t_{1})>,<\{s_{3},s_{11}\},[t_{1},t_{2})>,<\{s_{3},s_{11}\},[t_{2},t_{3}]>\}$ to the intermediate node $s_{4}$. In such a case, node $s_{1}$ will use the received $CLRSQ_{s_{2}}$ and the local information of itself to derive the $CLRSQ_{s_{1}}=\{<\{s_{1},s_{2}\},[t_{0},t_{1})>,<\{s_{1},s_{2}\},[t_{1},t_{2})>,<\{s_{2}\},[t_{2},t_{3}]>\}$; and node $s_{4}$ will use the received $CLRSQ_{s_{3}}$, $CLRSQ_{s_{5}}$, $CLRSQ_{s_{11}}$, and the local information of itself to calculate the $CLRSQ_{s_{4}}=\{<\{s_{4},s_{5}\},[t_{0},t_{1})>,<\{s_{3},s_{11}\},[t_{1},t_{2})>,<\{s_{3},s_{11}\},[t_{2},t_{3}]>\}$. Finally, with received $CLRSQ_{s_{1}}$ and $CLRSQ_{s_{4}}$, the query node $q$ can obtain a predicted final result of CRSQ, $DCRSQ(R,S,q,\varDelta t)=\{<\{s_{1},s_{4},s_{5}\},[t_{0},t_{1})>,<\{s_{1},s_{3},s_{11}\},[t_{1},t_{2})>,<\{s_{3},s_{11}\},[t_{2},t_{3}]>\}$, at time $t_{0}$.

Unfortunately, the predicted result may not be correct. In the above example, $DCRSQ(R,S,q,\varDelta t)$ is not equal to $CRSQ(R,S,q,\varDelta t)$ since the query node $q$ cannot obtain the information of node $s_{8}$ at time $t_{0}$. So the result needs to be updated continuously. In the DCRSQ process, three cases may happen if a node enters the range of $q$. First, if $s_{8}$ received a query message from $q$, $s_{8}$ would return its local range-skyline while entering the range of $q$. It means that at least one node locates in the range of $q$ at time $t_{0}$ and it is the intermediate (relay) node between $s_{8}$ and $q$. In such a case, the intermediate node has the information of $s_{8}$ and uses that to derive the predicted CLRSQ result. Then the predicted DCRSQ result should be a correct answer, $DCRSQ(R,S,q,\varDelta t)=\{<\{s_{1},s_{4},s_{5}\},[t_{0},t_{1})>,<\{s_{1},s_{8},s_{11}\},[t_{1},t_{2})>,<\{s_{8}\},[t_{2},t_{3}]>\}$. However, the mentioned example is not in this case since there is no intermediate node between $s_{8}$ and $q$. It is the second case that $s_{8}$ does not receive any information of $q$ at time $t_{0}$. According the assumptions of the DCRSQ process, $s_{8}$ will obtain the information of $q$ from its neighbors when $s_{8}$ enters the range of $q$ after time $t_{1}$. Hence, the RSQ results at time $t_{1}$ and $t_{2}$, $<\{s_{1},s_{3},s_{11}\},[t_{1},t_{2})>$ and $<\{s_{3},s_{11}\},[t_{2},t_{3}]>$, will be updated to $<\{s_{1},s_{8},s_{11}\},[t_{1},t_{2})>$ and $<\{s_{8}\},[t_{2},t_{3}]>$, since $s_{8}\triangleleft_{q}\{s_{3},s_{11}\}$. The last case is that $s_{8}$ cannot successfully obtain the information of $q$ when it enters the range of $q$. Such a case will be recognized as an incorrect result and it only occurs when the mobile environment is too sparse.

IV-B3 Description of DCRSQ

According to Definition 5, the system will process the CRSQ for a period of time $\varDelta t$ and derive the collection of possible answers. However, such a definition comes from the global and centralized view of system. In the previous subsection, the distributed method for processing RSQ has been introduced with Definition 6 and Definition 7. In the DCRSQ process, we use a mechanism to make each node able to predict the change of LRSQ answer with the node mobility. With above definitions and examples, the formal descriptions of CLRSQ and can be defined as Definition 8 and Definition 9 respectively.

Definition 8**.**

**(Continuous Local Range-Skyline Query)

Suppose that the notations are defined as above and a query $CRSQ(R,S,q,\varDelta t)$ is issued by the query node $q$. After a mobile sensor node $s_{j}$ receives the query message from $q$, $s_{j}$ will return a collection of local range-skyline sets $LRSQ_{s_{j}}(R,S,q,t_{i})$, where $t_{i}\in\varDelta t$ and $i$ is the number of local answer change. Formally, it is denoted as $CLRSQ_{s_{j}}(R,S,q,\varDelta t)=\{LRSQ_{s_{j}}(R,S,q,t_{i})|t_{i}\in\varDelta t,i\in N\}$.**

According to Definition 8, the query node $q$ will receive the results of $CLRSQ_{s_{j}}(R,S,q,\varDelta t)$, where $s_{j}$ is one-hop neighbor of $q$, $1\leq j\leq k$, and $k$ is the maximum number of neighbors. Then the query node $q$ will take the union of received results, which are the local range-skyline sets for time $t_{i}$, as $RSQ_{candidate}(R,S,q,t_{i})=\bigcup^{k}_{j=1}LRSQ_{s_{j}}(R,S,q,t_{i})$. Thus, the candidate collection can be denoted as $CRSQ_{candidate}=\{<RSQ_{candidate}(R,S,q,t_{0}),[t_{0},t_{1})>,<RSQ_{candidate}(R,S,q,t_{1}),[t_{1},t_{2})>,\dots,<RSQ_{candidate}(R,S,q,t_{i}),[t_{i},t_{end}]>\}$. After deriving $CRSQ_{candidate}$, $q$ will check the dominance relations of all objects in each $RSQ_{candidate}(R,S,q,t_{i})$ set again and then obtain the final result $DRSQ(R,S,q,t_{i})$ at each time $t_{i}$. We call such a process distributed continuous range-skyline query process (DCRSQ process) and the definition is given in Definition 9.

Definition 9**.**

**(Distributed Continuous Range-Skyline Query)

Suppose the candidate collection $CRSQ_{candidate}$ of query node $q$ has been computed. Query node $q$ uses $CRSQ_{candidate}$ to derive a collection of the range-skyline sets for different time $t_{i}$ and we use $DCRSQ(R,S,q,\varDelta t)$ to represent such a collection of continuous range-skyline sets, where $DCRSQ(R,S,q,\varDelta t)=\{DRSQ(R,S,q,t_{i})|t_{i}\in\varDelta t,i\in N\}$.**

Note that the fundamental process of DCRSQ is similar to DRSQ process mentioned in section IV-A3. The main difference is that each mobile node $s_{j}$ generates a continuous local range-skyline set $CLRSQ_{s_{j}}(R,S,q,\varDelta t)$ with the safe-time information of candidate nodes. Thus the DCRSQ process can provide sufficient information to the query node $q$ for deriving, predicting, and updating the answer as time continuously goes on. Algorithm 3 gives the high-level description of DCRSQ process. To implement Line 12 and Line 13 of Algorithm 3, we use the idea of sliding window, which is already a widely used design in many domains. Since it is out of the scope of this paper, we will not address it. In addition, if the $\varDelta t$ is the specific time of the query issuing, $[t_{i},t_{i}]$, $t_{i}\geq 0$, the query will be a snapshot RSQ and the DCRSQ will do the same process as the DRSQ process does.

V Cost Analysis and Discussion

Suppose that $N$ mobile data objects are distributed independently and uniformly in the sensing area, $\mathcal{A}$, and each data object has $d$ attributes. If all the attributes of each object are in a uniform distribution, the skyline search problem can be treated as the problem of finding the maxima [24] in an $N\times d$ matrix. Hence, the expected size of skyline will be $n_{sky}=O((\ln N)^{d-1})$. In the considered environment, the query node does not need to process all the mobile sensor nodes (or data objects) for the range-skyline query and thus the expected size of range-skyline will be $n_{range-sky}=O((\ln N_{R})^{d-1})\leq O((\ln N)^{d-1})$, where $N_{R}$ is the number of mobile sensor nodes in the query range $R$ and $0\leq N_{R}\leq N$. Note that the value of $N_{R}$ is influenced by the value of $N$, sensing area $|\mathcal{A}|$ and the query range $R$ and $N_{R}=\lfloor\frac{\pi R^{2}N}{|\mathcal{A}|}\rfloor$. According to the above notations, the average number of data objects in the transmission range of a mobile sensor node will be $N_{r}=\lfloor\frac{\pi r^{2}N}{|\mathcal{A}|}\rfloor$, where $r$ is the transmission range of a mobile sensor node. If $N_{r}\leq 1$, the density of mobile sensor nodes is too sparse and thus it is too hard to route messages. In such a case, none of the conventional centralized and proposed approaches can perform well in the CRSQ processing. Hence, we only discuss the case, $N_{r}>1$, in this work. Note that we do not discuss the case here $N_{R}\leq 1$ since none of mobile sensor nodes can serve this query.

In the considered IoMT, the mobile sensor nodes in the query range have to return information to the query node in hop-by-hop manner. The possibility distribution function of each hop in a multi-hop wireless environment has been discussed in [25] and we use that to obtain the possibility $P_{i}$ of the $i$th hop transmission. To obtain sufficient information for deriving the accurate result of a RSQ, the system must guarantee that more than $N_{R}$ neighboring nodes of the query node can receive the query message. Then we can denote such an expected network cost for spreading the query message as

[TABLE]

where $N_{r}^{i}$ is the average number of $i$th-hop neighbors with respect to the query node $q$. Since all sensor nodes in the query range should be notified with the query messages from $q$, we can find a minimum value of $k\in\mathbb{N}$ that $E[q_{spread}]\geq N_{R}$. Hence, the expected hop count $TTL_{q}$ can be derived by (2) and $TTL_{q}=k$.

The process of data collection in the centralized approach is straightforward and each of the mobile sensor node which receives the query message will return the information of itself to the query node. Since the $i$th-hop neighbor needs to return an $i$-hop response message to the query node, the network cost of the reply messages for the $i$th-hop neighbors will be $N_{r}^{i}\times i\prod_{j=1}^{i}P_{j}$ without the cooperative pruning. Hence, the expected network cost for returning messages in the centralized approach can be denoted as

[TABLE]

where $k=TTL_{q}$ is determined by (2) with the constraint $E[q_{spread}]\geq N_{R}$. In summary, the total network cost of the centralized approach for a RSQ, $q$, can be denoted as

[TABLE]

In the proposed approach, DRSQ process, each node derives the local range-skyline and the expected size of result is $O(\ln N_{r})^{d-1}$. The reason is that DRSQ process combines the information filtering into the data collection, thus reducing a large number of irrelevant response messages. Hence, the network cost for replying the information can be denoted as

[TABLE]

and $E_{DRSQ}[q_{response}]<E_{centralized}[q_{response}]$ in normal cases. So the total network cost of DRSQ process can be estimated as

[TABLE]

For monitoring a CRSQ query in the centralized approach, the query node has to spread the query message periodically during the time period $\varDelta t$ and each neighboring node also has to periodically return the information of itself. So the network cost of the centralized approach can be denoted as

[TABLE]

where $T$ is the time interval that each mobile sensor node periodically reports the updated information to the query node and the default value of $T$ is 1 second. In DCRSQ process, the query node does not have to periodically spread query messages since each mobile sensor node can buffered the information of the query. So the network cost is mainly influenced by the frequency of the answer changes and it can be derived by

[TABLE]

where $\overline{T_{safe}}$ is the average safe-time that the result needs to be updated.

VI Simulation Results

All of the simulations are implemented as custom programs using C++ and executed on a Windows 7 system with an Intel i5-4460 3.20GHz CPU and 8GB memory. In all the simulation scenarios, the mobile sensor nodes are distributed uniformly and the results are reported with the average of 200 executions. The used mobility model is Random Way Point (RWP) and the network routing protocol is AODV [26]. Since none of existing works provides distributed RSQ process over IoMT environments, we thereby use a centralized method [7] as the compared centralized approach and it is executed on the query node for calculating the query results. In the centralized approach, the query node directly uses the flooding scheme to spread query messages and then collects information from moving data objects.

The proposed approach, DCRSQ process, can support (snapshot) range-skyline query and continuous range-skyline query. If $\varDelta t=[t_{0},t_{end}]=0$, where $t_{0}=t_{end}$, the DCRSQ process will perform the DRSQ process for deriving the results of the (snapshot) RSQ at time $t_{0}$. We thus organize the simulation section as two scenarios. In the first scenario, we discuss the performance of DRSQ process in terms of response time and number of messages. The response time is the period of time from issuing a RSQ to obtaining the result during the DRSQ process. The number of messages represents the necessary network cost on data collection.

In the second scenario, the performance of DCRSQ process is discussed in terms of number of accessed objects and number of messages. Additionally, the correctness of DCRSQ result is discussed in terms of precision and recall. In both scenarios, the following important factors are discussed: density (number of sensor nodes), number of queries, query range, and transmission range. For validating the DCRSQ process, an additional factor, node speed, is also in the discussion.

VI-A Scenario I: Performance of DRSQ Process

In the first scenario, we discuss the performance of DRSQ process. There are $100$ mobile sensor nodes in a $400m\times 400m$ square sensing area. The default transmission range is $75m$ and the node speed is $5m/s$. Initially, mobile sensor nodes and queries are placed randomly in the area. The basic simulation settings for the first scenario are shown in TABLE III and, we execute the simulation 200 times to get the average results and the $95\%$ confidence intervals under each scenario.

To the best of our knowledge, none of existing works proposed a method for processing range-skyline queries in such an environment, where the databases, CPUs, and memory are fully-distributed. We hence compare the proposed approach, DRSQ process, with a centralized approach which is a baseline. Note that the centralized approach does not use a powerful server. In the centralized approach, we assume that the query node is a sink node and can process the query with received information. The other mobile nodes only just forward the query and response messages without processing the local range-skyline.

VI-A1 DRSQ: Density

Fig. 6(a) shows that the response time of our proposed distributed approach, DRSQ process, is $10\%$ better than the centralized approach when the density becomes more dense (the number of sensor nodes increases). Although both centralized approach and DRSQ process need to collect the information from the other sensor nodes, DRSQ process spends less time on data collection. There are two reasons. One is that DRSQ process only needs to access the sensor nodes around the query range. Conversely, the centralized approach asks all the sensor nodes in the considered environment for data collection. The other reason is that the query node using the centralized approach needs to process many data objects and the computation overhead is thus heavy.

Fig. 6(b) presents that DRSQ process is almost $75\%$ better than the centralized approach in term of number of messages. In the DRSQ process, each mobile sensor node collects the information of its neighbors and derives a local RSQ result before sending a response message to the query node. Such a process can effectively prune a lot of irrelevant information from data objects (sensor nodes) and thus cost less number of messages on returning the local range-skyline. On the contrary, the centralized approach just floods query messages and collects the information from all the neighboring mobile sensor nodes to derive the range-skyline. It thus wastes more network cost on data collection.

VI-A2 DRSQ: Number of Queries

In this subsection, we discuss the impact of the number of queries. The number of queries indicates the maximum number of queries concurrently processed in the system. Fig. 7(a) shows that the response time of DRSQ process is much better than the centralized approach as the number of queries increases. When the number of queries is $5$, the DRSQ process performs almost $30\%$ faster than the centralized approach does. The DRSQ process only needs to access the sensor nodes which are around the query range. In contrast, the centralized approach floods query messages to asks all the sensor nodes in the considered environment for data collection. As the number of queries increases, a large amount of flooding messages harms the network routing performance and thus increases the response time. In addition, the query node using the centralized approach needs to process more information from data objects, so the overhead of RSQ computing on the query node becomes heavy. This can be verified by the experimental results shown in Fig. 7(b). As the result indicates, the DRSQ process costs $20\%$ to $50\%$ fewer number of messages than the centralized approach does since it can avoid irrelevant data objects during data collection, and thus reducing a large amount of duplicated messages for data transmissions.

VI-A3 DRSQ: Query Range

Different values on the query range also influence the performance of query processing. Fig. 8(a) shows that the DRSQ process outperforms the centralized approach by $2\%$ to $10\%$ in term of response time with all different range values. When the query range $R$ is smaller than the transmission range $r$, the probability that the whole query range falls in the transmission range is high and it thus is easier for the query node to obtain the RSQ result by collecting sufficient information from its one-hop neighbors. When the query range $R$ is larger than the transmission range $r$, the DRSQ process only needs to access the sensor nodes which are around the query range instead of accessing all the sensor nodes as the centralized approach does. So, the DRSQ process can outperform the centralized approach on response time. Fig. 8(b) shows that DRSQ saves almost $80\%$ transmission cost in comparison with the centralized approach. The reason is that the DRSQ process can effectively prune the irrelevant information from data objects during data (local skyline) collection.

VI-A4 DRSQ: Transmission Range

The last important impact is the transmission range $r$ of a sensor node. As Fig. 9(a) indicates, the distributed approach outperforms the centralized approach by $5\%$ to $10\%$ with different transmission ranges in terms of the response time. Unlike the dramatic increasing response time of the centralized approach, the response time of DRSQ process increases more gently. The centralized approach has to do the dominance checks after it receives a large amount of information from the neighboring sensor nodes. So, it needs more computation overhead. Instead, the DRSQ process can avoid the irrelevant data objects in a distributed way during the information collection. The query node only processes the one-hop neighbors’ local range-skyline sets whose sizes are much smaller than the sizes of the data sets in the centralized approach on the query node. Effectively pruning irrelevant data objects in a distributed way also reduces a lot of required messages for returning the local range-skyline sets to the query node and this trend is demonstrated in Fig. 9(b). DRSQ can save $60\%$ to $70\%$ transmission cost on the data collection.

VI-B Scenario II: Performance of DCRSQ Process

In the second scenario, we present the performance results of DCRSQ process. The duration of each query $\varDelta t$ is $10$ seconds and the total duration of the simulation is 60 seconds. Initially, the mobile sensor nodes and query nodes are placed randomly in a $500m\times 500m$ square area. For each simulation set, we execute the simulation 200 times to get the average results and the $95\%$ confidence intervals. The $t_{0}$ of each query’s $\varDelta t$ is randomly generated from second 1 to 50. The other important settings are shown in Table IV.

The system will continuously return results for a CRSQ query within the time period $\varDelta t$, so it is difficult to measure the response time precisely. Instead, we observe the number of accessed objects (collected data objects) on each query node. If the number of accessed objects on the query node is small, it means that the efficiency of DCRSQ process is better since a large number of irrelevant data objects are skipped during message routing. For the DCRSQ process in a mobile environment, the node speed is one of the important factors. If the node speed becomes fast, it may lead the answer changing more frequently and the overhead of processing CRSQ queries also becomes heavier. We thus discuss the impact of node speed on the performance of DCRSQ process. In addition, we use a server to check the correctness of results, generated by the DCRSQ process and the centralized approaches respectively in terms of precision and recall. Note that the server has a global knowledge of all the data objects and always generates the correct answer for a query.

VI-B1 DCRSQ: Density

Fig. 10(a) shows that DCRSQ process is better than the centralized approach in terms of number of accessed objects. When the number of mobile sensors increases, the total number of accessed objects in the proposed method remains constant that is no more 1100 nodes. In contrast, using the centralized way, a query point needs about 2 to 5.5 times more nodes to derive the final range-skyline. This is due to no process of discarding irrelevant moving objects during data collection (local range-skyline processing) in the centralized approach. In summary, DCRSQ can save $50\%$ to $80\%$ computational cost in average for a query.

Similarly, Fig. 10(b) shows that DCRSQ process is better than the centralized approach in terms of number of messages. In DCRSQ process, each mobile sensor node collects the information of its neighbors and derives a local RSQ result before sending a response message to the query node. Such a process can prune a lot of moving objects which will not be the candidates and thus cost less number of messages on returning local range-skyline. On the other hand, the centralized approach just floods query messages and collects the information of all neighboring mobile sensor nodes for deriving the final range-skyline. So, the centralized approach wastes $10\%$ to $20\%$ more network cost on data collection.

For the accuracy, each mobile sensor node in the centralized approach does not consider the prediction location of the neighbor nodes. Each sensor node only forwards the collected information to the query point. The result of final range-skyline may be inaccurate, so we compare the results of DCRSQ process and centralized approach with the answer in a server to measure the precision and recall. Fig. 10(c) and Fig. 10(d) show that both precision and recall of the centralized approach are worse than DCRSQ process by $10\%$ to $20\%$. Moreover, precision and recall of DCRSQ process are almost $100\%$ correct when the number of sensor nodes is large.

VI-B2 DCRSQ: Number of Queries

In this simulation experiment, we are interested in evaluating the performance of different number of queries issued simultaneously. We set the number of queries from 1 to 10, which means that there are at most 10 queries within the time period $\varDelta t$ in the simulation. Fig. 11(a) and Fig. 11(b) show that as the number of queries increases, the number of messages and the number of accessed objects grow up respectively for both approaches. However, DCRSQ process only needs to access $50\%$ to $70\%$ amount of data objects in the derivation comparing to the centralized approach. DCRSQ outperforms the centralized approach and saves about $30\%$ on network cost when the number of queries is smaller then 7. If the number of queries exceeds 7, DCRSQ will cost more network messages. The reason is that the neighboring nodes cooperatively process the local result of CRSQ and some of them store duplicated local results (objects). That is, the query node may receive many duplicated reply messages.

Fig. 11(c) and Fig. 11(d) show that DCRSQ process is better than the centralized approach in terms of precision and recall. As the number of queries increases, DCRSQ process still can achieve almost $90\%$ correctness and outperforms the centralized approach by $12\%$ to $25\%$ in terms of precision and recall, respectively. The reason is that DCRSQ process does not compute the irrelevant data objects anymore since they have already been filtered by the neighboring mobile nodes. Thus, a query point only checks the dominance objects that can guarantee to be in the final range-skyline. The other reason is that each mobile sensor node in the centralized way just gathers the information of its neighbors and sends the information back to the query node for deriving final range-skyline. Therefore, there is a possibility to compute a large number of irrelevant data objects for the query node. Thus, it makes the precision and recall of the centralized approach worse than the DCRSQ process. Although DCRSQ still has many redundant transmissions we mentioned above (in Fig. 11(b)), such duplicate local results significantly recover transmission failures and thus increase the precision and recall of the query result.

VI-B3 DCRSQ: Query Range

In this simulation set, we discuss the results of varying the query range. In Fig. 12(a), the number of accessed objects in the centralized approach remains around 3000 nodes for the final range-skyline in query point. However, the number of accessed node increases slightly when the query range becomes larger. It means that the query node in DCRSQ can save almost $30\%$ to $80\%$ computational cost in comparison with the centralized approach. As shown in Fig. 12(b), when the query range increases, the number of messages in the centralized approach is always about $1.7\times 10^{5}$ because it always floods messages to the whole sensing area. DCRSQ process needs much less network cost than the centralized approach when the query range is smaller than 150 meters and only performs slightly worse when the query range is 200 meters. The possible reason is that the DCRSQ still costs too much network messages on exchanging information between the irrelevant nodes which are very far away from the query node.

As for the accuracy shown in Fig. 12(c) and Fig. 12(d), the trends in centralized approach, in comparison with the previous two measurements, are different. With the wider range of a query, the percentage of recall drops rapidly down about 40$\%$ in the centralized approach. Recall that all the neighboring sensor nodes have to report their information to the query node continuously for CRSQ queries in the centralized approach. As the query range becomes larger, more neighboring sensor nodes need to continuously report their information without data pruning. In such a scenario, the query node will be a bottleneck of the system and thus many messages may be dropped. Due to the above reason, the precision and recall of the centralized approach decrease significantly. On the contrary, the DCRSQ process already computes the range-skyline locally and the local range-skyline candidate sets are continuously sent back to the query node for deriving the final range-skyline. Such a way can reduce large amount of network cost and avoid the bottleneck problem on the query node. Thus, the accuracy of our approach can achieve over $92\%$ better.

VI-B4 DCRSQ: Transmission Range

Transmission range (or sensing range) of each object is also an important impact factor. We therefore measure the performance on different values of transmission range. As shown in Fig. 13(a), the number of accessed objects in DCRSQ process is much less than the centralized approach by up to $80\%$ if the transmission range is $125$ meters. Filtering unnecessary data objects in a distributed way can reduce a lot of required messages for returning the local range-skyline sets to the query point. Fig. 13(b) shows that DCRSQ process outperforms the centralized approach by up to $25\%$ with different settings of transmission range in terms of the number of messages. Unlike the dramatic increasing of the number of messages in the centralized approach, the number of messages in DCRSQ process increases more slowly. The reason is that each mobile node in the centralized approach brings a large number of data objects from neighboring sensor nodes before forwarding them back to the query node.

Fig. 13(c) and Fig. 13(d) show the accuracy of both approaches. For the centralized approach, the precision and recall are under $50\%$ when $r=50$, and jump to more than $90\%$ if $r$ becomes larger than $100$ meters. The reason is that each mobile sensor node may not successfully transmit information to others while the transmission range becomes too small. In contrast, DCRSQ process can achieve $98\%$ precision and recall since DCRSQ process uses safe time to predict the locations of its neighbors and thus provides more accurate results in the final range-skyline sets.

VI-B5 DCRSQ: Node Speed

The last simulation experiment investigates the effect of mobile sensor node’s speed. We vary the maximum value of node speed from $5$ to $30$ $m/s$ in the simulation. Fig. 14 indicates that all the trends are gradually decreasing and our proposed method, DCRSQ process, always has a better performance than the centralized approach. Fig. 14(a) and Fig. 14(b) show that DCRSQ outperforms the centralized approach in terms of the number of accessed objects and the number of messages. Note that each mobile sensor node in DCRSQ process knows when the neighboring nodes enter and leave the query range in advance. It thus can save almost $20\%$ to $90\%$ message cost on query processing and reduce $60\%$ amount of accessed objects for deriving the final skyline result on the query node.

In addition, when each mobile node moves faster, the neighbors will change more frequently and wireless connections between mobile sensor nodes become more unstable. Hence, in high-speed scenarios, it is more difficult for the query node to collect sufficient information to derive the accurate result. Fig. 14(c) and Fig. 14(d) show that both DCRSQ and the centralized approach has the similar trends of performance on precision and recall. Comparing to the centralized approach, DCRSQ has $20\%$ improvement in average on the precision and recall.

VII Conclusion

In IoMT, very few works discuss the RSQ and CRSQ queries while simultaneously considering the following constraints: distributed computing units and databases on different mobile sensor nodes databases, moving data objects, and the mobile query. We hence propose a Distributed Continuous Range-Skyline Query process (DCRSQ process), for driving the results of RSQ and CRSQ queries. The main idea of the proposed DCRSQ process is to predict the appropriate time, safe-time, that the answer of a query changes. We apply such a prediction to each mobile sensor node and query node, so each mobile sensor node can compute the local result more precisely and then provide the local result to the query node for computing the final result. Instead of processing the information of all the neighboring mobile sensor nodes on the query node, the proposed distributed and cooperative approach with safe-time prediction can effectively reduce the computation overhead of the query node. The performance of DCRSQ process is also validated by the extensive simulation experiments. In some scenarios, the performance of DCRSQ process is almost 80% better than the performance of the centralized approach in terms of the number of accessed objects. The DCRSQ process saves more than 15% network cost in terms of the number of messages in general. In most scenarios, the DCRSQ process outperforms the centralized approach by more than 10% to 25% accuracy (precision and recall).

In this work, we propose a prototype of distributed query process for CRSQ and simply use 2 dimensional data objects (distance and sensing value) to valid the performance in the simulation. For each sensor node, it needs to buffer the received query information and then help the data filtering and local computation until the query time is expired. Hence, there is one possible future research direction to find the relation between the minimum requirement (CPU and memory/storage) of each sensor and a parameterized (report/sense rate, number of sensor nodes and number of queries, etc.) IoT environment. Another possible future research work is to implement the distributed multi-criteria decision services on different modern open source IoT constrained platform [27] or simulators [28]. Such a way can help the research and open source communities for evaluating. In the future, we are going to develop distributed approaches for monitoring different spatial queries in practical drone-assisted IoMT applications [29].

Acknowledgment

This research is partially supported by Ministry of Science and Technology under the Grant MOST 107-2221-E-027-099-MY2 and MOST 108-2634-F-009-006- through Pervasive Artificial Intelligence Research (PAIR) Labs, Taiwan.