A novel routing protocol for content-based publish/subscribe model in mobile sensor networks

Abstract

In the mobile sensor networks, the sink node registers its own events in the network, and when the sensor node finds an event of interest to the sink node, it sends a response message. The data traffic of the communication process in the application scenario has a bursting feature, and sometimes network congestion occurs. Therefore, when designing the data routing protocol, it is necessary to consider how to reduce the communication overhead in the network and improve the success rate of the query. To address this issue, this article proposes a routing protocol for content-based publish/subscribe, which is applicable in mobile sensor networks. The core idea of routing protocol for content-based publish/subscribe is that all sensor nodes in the network are divided into several clusters, and the transmission of sensing events is based on these clusters. The protocol consists of event publishing, subscription, matching, and unsubscribe. The inquirers send subscription information to the network, which are saved in the cluster head network. Published events are also transmitted to the cluster head network and the matching computation is performed. If the match is successful, events will be sent to subscribers, thus improving the success rate of queries. The simulations show that compared with existing methods, routing protocol for content-based publish/subscribe consumes lower matching events transmission energy to obtain a higher success rate. In the case of a large number of published events, the network lifetime of the routing protocol for content-based publish/subscribe protocol can be increased by 28%–54%, and the subscription success rate remains above 80%.

Keywords

Mobile sensor networks publish/subscribe model content matching routing protocol data collection

Introduction

In an event-driven sensor network, the mobile sink node will register only the events in the system that it is interested. When the sensor node finds the events that the sink node is interested in, it will send out the response events. This process is also known as push mode, which is a kind of many to one communication.¹ This mode is often used in monitoring multiple abnormal events. The emphasis on the data transmission process is the timeliness and reliability of communication. The data transmission is bursty, which results in network congestion. Therefore, it is necessary to consider how to reduce the communication cost when designing the data transmission protocol.

Mobile sensor network (MSN) is a common event-driven sensor network. At present, most of the researches on MSN data collection technology are aimed at how to collect the data from the sensor to a single or multiple aggregation points as indistinguishable as possible.^2,3 However, in practical applications, the types of data collected by each sensor are diverse. Because the receiver of the data may only be interested in one or some of them, these data need to be transmitted by classification. For example, at disaster relief sites, different teams only need data about their respective areas of assistance.⁴ For another example, different personnel are interested in different information in a military combat system. A soldier may only need data about the distribution of the enemy forces around him, while the command and control department need information about the overall deployment status of the battle field.⁵ Another example is the monitoring of diseases in life. We can send the data of different kinds of diseases collected by sensors to different monitoring agencies for timely processing.⁶ In order to meet the requirements of the above applications, it is necessary to set up a highly flexible and dynamic data distribution and processing system. Such data distribution and processing capabilities are provided by publish/subscribe (pub/sub) systems.⁷

The implementation of the subscribe/publish function of a sensor network is challenging because the subscriber node does not know when and where the events of interest occur, and the publish node does not know which node in the sensor network is aware of the published events of interest to it. The simplest way to allow publishers and subscribers to communicate with each other is to use a radio policy, such as sending subscription messages to all nodes in broadcast form, or publishing all events to all nodes in broadcast form. Although this broadcast strategy can transmit event messages rapidly, its communication cost is intolerable for resource-constrained MSNs.⁸ Another approach is to provide a central node to receive all subscription messages and publish them. Although the communication cost is minimized, the load on the central node is very large, especially when the number of subscribed messages and published messages is large. Consequently, the energy of the central node will be quickly exhausted, making the continuous communication on the network ineffective.⁹

Most of the existing routing protocols are directed at traditional sensor networks, and the adaptability to mobile sink nodes is not good. Therefore, it is necessary to conduct new research on the scenarios of MSN. Combining the characteristics of the publish/subscribe system and MSN, this article proposes the routing protocol for content-based publish/subscribe (RPCP), a routing protocol based on content coverage publish and subscribe models. The protocol consists of event publishing, subscription, matching, and unsubscribe. The inquirers send subscription information to the network, which are saved in the cluster head network. Published events are also transmitted to the cluster head network, and the matching computation is performed. If the match is successful, events will be sent to subscribers to improve the transmission success rate while minimizing the energy consumption of sensor nodes. The design of RPCP protocol is suitable for MSN.

Related works

There are two kinds of nodes in MSN, namely static sensor nodes and mobile sink nodes with sufficient energy. The sensor node collects the data transmission process of the sensing data along the predetermined route to the mobile sink node, which can also be invoked based on the event propagation process.¹⁰ The subscription/publication model is introduced into the MSN. When an aggregation node is interested in an event in the network, it can tell the MSN it is interested in the event by sending subscription information, and then, the sink node does not have to wait. When the sensor node detects the occurrence of such events, it sends a relevant event message to the interested sink node. It can also specify some event patterns and only notify the sink node when the event matches these patterns.¹¹ This pattern of data transmission when events occur in the network makes it an event-driven network.

For the problem that data cannot be served due to client mobility, some studies have proposed their own methods. For example, a study¹² proposes an event submission protocol based on client destination prediction. However, this protocol ignores that the arrival of events in the process of client mobility is a continuous feature. How to solve this problem has become a severe test for the system. Another study¹³considers the issue of publisher mobility and proposes four strategies to reduce the impact of publisher mobility on system performance. In addition, Leyva-Mayorga et al.¹⁴ propose a novel algorithm to enhance the reliability of the highly dynamic network events in the transmission, which provides strong expressiveness but is less efficient. Tekin and Sahingoz¹⁵ proposed a topic-based publish and subscribe mechanism (PSM). By using this mechanism, it is aimed to decrease the energy consumption and increase the network lifetime. The algorithm has a large event transmission delay, and the node periodically broadcasts its own subscription conditions across the entire network, causing a large amount of energy consumption and resource waste.

The communication, computing, and storage capabilities of sensor nodes may be limited, due to a fault or failure. In addition, MSNs do not require infrastructure and have strong autonomy. Therefore, it is unrealistic to choose a sensor node as a central node in MSNs to receive messages from subscribers and publishers. In order to adopt subscription/publication mechanism in MSNs, some nodes can be selected as message brokers, and cluster heads can be chosen to play this role.¹⁶ The choice of cluster heads is very important, and improper selection of cluster heads will result in inefficient data transmission.

A study by Liu et al.¹⁷ presents a community-based event transmitting protocol (CETP). The core idea of this protocol is that all sensor nodes in the network form a number of fixed communities based on their interconnection and transmit events based on these communities. CETP protocol consists of two parts: event transmission and queue management. In event propagation strategy, besides sending as many events as possible to mobile users, some events stored by mobile users will also be sent back to sensor nodes in the community to improve the success rate of event transmission; queue management is event based. The number and lifetime of successful transmission determine the importance of events in the storage queue and the discarding principle, thus reducing the energy consumption of network transmission. The disadvantage of the CETP is that some nodes may be outside the community, causing the loss of perceived data.

Fan et al.¹⁸ use a mobile sink to travel around the monitoring area. When the mobile sink travels to a position, it serves as a new source. Since multiple sources can simultaneously forward data packets, flooding speed can be accelerated. The information transfer of this method leads to a large query delay. S Ganala¹⁹ formulates the problem of scheduling the MSN in distributed manner so that the entire region is covered without coverage holes with minimum energy depletion. Finally, some computationally practical algorithms for multiple MSNs with fault and non-fault tolerant support are presented. Due to the distributed storage and matching of data, the query efficiency of this method is not high. Kumar et al.²⁰ propose a new ant colony optimization–based mobile sink path determination for MSNs. The objective of the proposed algorithm is to maximize the network lifetime and minimize the delay in collecting data from the sensor nodes. The disadvantage of this algorithm is that the data matching is more complicated, and the energy consumption of the node is larger, thereby reducing the network lifetime.

In MSNs, nodes are in a form of dynamic self-organization. Due to the continuous joining and exiting of nodes, the network topology changes. Publishing and subscribing system can adapt well to dynamic situations. That is to say, sensor nodes can publish their capabilities to the proxy nodes in the network, and the proxy nodes report according to the sensor nodes. The availability of the capability information of the sensor nodes, and an intelligent distribution of subscription information sent by the upper layer, makes the subscription information more targeted, but also reduce the communication of redundant information, which can effectively reduce energy consumption. In addition, the information returned by multiple nodes can be efficiently fused in the proxy node, thus further reducing the amount of data transmission.

Network model

The routing topology of sensor networks can be divided into two categories: planar structure and cluster structure. Planar structure means that all nodes in the network are identical in function and status and complete communication tasks together. The advantages of this structure are simple topology, easy implementation of routing algorithm, no need for too much structural maintenance, and no special nodes in the network. The status of all nodes in the network is equal. If a node dies, the other can take its place; hence, such a network structure is very robust. The disadvantage of this structure is poor scalability. That is, when the network monitoring range changes dramatically, there is the need to recalculate the routing.²¹

Contrary to the planar structure, the nodes in the network have different levels. Some are ordinary sensor nodes, while others act as managers.²² Cluster routing protocol divides sensor nodes into hierarchical levels. As shown in Figure 1, several adjacent nodes form a cluster and one node in each cluster acts as the cluster head. Two cluster heads can communicate directly to form a basic network backbone. All cluster communications are forwarded through the backbone network.

Figure 1.

Network topology with cluster structure.

The cluster routing protocol includes four parts: a clustering protocol, a cluster maintenance protocol, a cluster internal routing protocol, and an inter cluster routing protocol. The clustering protocol solves how to effectively partition sensor nodes into clusters in a dynamic distributed network environment. It is the key to the cluster routing protocol. The cluster maintenance protocol is responsible for the maintenance of the cluster structure during the node movement process, including the functions of the clusters exiting and adding mobile node, cluster generation, and extinction. The inter-cluster routing protocol solves the data communication between the clusters and realizes the transmission of information among the clusters through the cluster heads. The clustering algorithm uses the method proposed by Abushiba et al.²³ The energy consumptions of cluster heads are normally high and it is easy for information in transmission to die prematurely. Therefore, the proposed algorithm will select a cluster head according to its energy consumption and perform the migration of subscription events.

The publish/subscribe system of MSNs is also composed of event publishers, event subscribers, and event agents, in which cluster heads act as agents. According to the proposed network model, the publish/subscribe system of RPCP consists of two layers. The first layer is the static sensor nodes with random distribution. They collect data and act as publishers to organize these data into events for sending. The second layer is the backbone network composed of cluster heads, which acts as agents for temporary storage and content matching of events and are responsible for data transmission. Random mobile nodes, which can be people, vehicles, and so on, generally have high energy and large storage space. They are subscribers in the network having their own subscription conditions and are interested in specific events.

Similar to most existing publish/subscribe systems, the key problem that MSN publish/subscribe systems need to solve is how to make published events reach interested subscribers as low in cost, efficient, and reliable as possible. In routing transmission strategy, the average transmission success rate of events is the most important design goal. Apart from the success rate of event transmission, energy consumption should also be taken into account. In order to achieve a balance between transmission delay and energy consumption, this article proposes an event transfer protocol RPCP based on publish/subscribe mode in MSN. The next section describes the RPCP protocol in detail.

The RPCP

In event-driven sensor networks, mobile sink acts as a subscriber. The cluster heads of each cluster are content classification libraries and message agents, and the sensor nodes are publishers.

Assuming that a subscription event consists of a set of overridden attributes, all attributes matching the subscription content S are recorded as N(S). For subscriptions S₁ and S₂, if $N (S_{1}) \supseteq N (S_{2})$ , then S₁ covers S₂, and it is denoted as S₁ → S₂. Also, if $N (S_{1}) \equiv N (S_{2})$ , then S₁ is equivalent to S₂, and it is denoted as $S_{1} \equiv S_{2}$ . If subscription S₁ covers S₂, only S₁ needs to be forwarded to the upstream content cluster head, and the overwritten subscription is no longer forwarded to the upstream cluster head, thus reducing the routing table size of the cluster head.

Let addSub(S) denote the establishment of a new subscription S and cancelSub(S) denote the cancelation of subscription (S). The idea of optimizing subscription coverage can be implemented in the following steps:

Step 1. If a subscription overriding S has been forwarded to the upstream content cluster head, addSub(S) will no longer forward to the upstream.

Step 2. When the upstream content cluster head receives addSub(S), deletes the routing table entries that are covered by S.

Step 3. If a query in the subscription table indicates that the overriding subscription S forwarded to an upstream cluster head has not been canceled, cancelSub(S) will not be forwarded to the cluster head at the same time.

Step 4. If cancelSub(S) is successful, end the algorithm.

For subscriptions S₁ and S₂, and S₁ → S₂, if addSub(S₁) and addSub(S₂) come from the same node P, then S₂ is received first. This subscription mode will delete the entries of S₂ from the routing table to minimize the size of the routing table. If cancelSub(S₁) is issued before cancelSub(S₂), the subscription mode will resend the subscription S₂. From the above-mentioned description, we can see that in order to minimize the size of the routing table, more computational costs are required. In this article, a suboptimal content coverage subscription algorithm is proposed and adopted. Its idea is described as follows:

Step 1. If a subscription covering S has been forwarded to the upstream content cluster head, addSub(S) will no longer forward to the cluster head.

Step 2. If the subscription overwriting S that has been forwarded to the upstream content cluster head is not unsubscribed and addSub(S) has not been forwarded to the cluster head, then cancelSub(S) will not be forwarded to the cluster head.

Step 3. If cancelSub(S) is forwarded, it is necessary to reconsider whether to forward subscriptions covered by S.

Suboptimal subscription coverage acknowledges the fact that subscription information has been forwarded. When processing subscriptions, it does not consider whether current subscriptions cover previously received subscriptions. That is, it does not delete the subscriptions from existing subscriptions that are covered by current subscriptions, and it does not recalculate the subscription coverage relation when canceling subscriptions. For subscriptions S₁ and S₂, where S₁ → S₂, if addSub(S₂) and addSub(S₁) come from the same node P, S₂ is received first; the suboptimal subscription coverage mode does not delete the subscription S₂ after receiving the subscription S₁, but still maintains the relation S₁ → S₂ on the cluster head. If S₁ is received prior to S₂, there is no need to retain subscription S₂ on the cluster head. That is to say, suboptimal subscription coverage is affected by the order of subscription and therefore the size of the subscription content on the cluster head.

Selective coverage subscription content routing is based on coverage technology and utilizes the following principles: if subscription S₁ covers S₂, only S₁ needs to be sent to the upstream cluster head, because S₁ can express interest on behalf of S₂. The covered subscription does not need to be forwarded to all content cluster heads, thus reducing the subscription size and routing table size of cluster head. The following sections provide an algorithmic description of the publish/subscribe system of sensor networks, by considering the algorithms for message publishing, message subscription, content matching, and message unsubscribe.

Message subscription algorithm

Message subscription algorithm in publish/subscribe systems describes the transmission of subscription messages from the sink node of subscribers to the network. The subscription messages are transmitted in the network and temporarily stored in cluster head nodes. As shown in Figure 2, subscription S₁ has previously maintained a copy on each cluster head upstream.

Figure 2.

Subscription scheme.

At this time, node C₂ publishes a subscription S₂ upstream. When cluster head R₁ receives S₂, the subscription module is responsible for judging the relation between S₂ and S₁. When the relation between S₁ and S₂ is determined, the relation will be maintained in cluster head R₁. Because S₁ covers S₂, there is no need to forward S₂ upstream. So, in the upstream cluster head R₃ of R₁, there is no need to maintain a copy of S₂. Similarly, because S₃ and S₄ satisfy the relation of S₃ → S₄, the relation of S₃ → S₄ is maintained on cluster head R₂, and no further transmission of S₄ to upstream cluster head R₃ is needed. According to the content forwarding strategy, the more coverage relations between subscription content (expressions), the smaller number of clusters will be maintained on the higher level.

How to maintain the relation between subscriptions in publish/subscribe system is the most critical issue. This will involve performance issues such as correctness, efficiency, and dynamic adjusting function.

For any node R representing a content cluster head in the content routing network, the subscription algorithm is shown in Algorithm 1. After receiving the subscription information from the downstream nodes, the cluster head node updates its own routing table. Then, look at the upstream cluster head list and forward the subscription information.

Algorithm 1. Message subscription algorithm
Input: Received subscriptions $Adv (S)$ Output: Updated subscriptions $Adv (S')$ 1: Receiving subscriptions from downstream nodes $Adv (S)$ ; 2: Update R’s routing table; 3: if Need to send to upstream cluster then 4: Revision of subscription content (expression) $S \to S'$ ; 5: Forward $Adv (S')$ ; 6: end if 7: end

Message publishing algorithm

In the publishing algorithm of publish/subscribe system, sensor nodes in the network try their best to find the appropriate path, so that the perceived data can be sent to subscribers efficiently and reliably. The goal of message publishing algorithm design includes reliable message forwarding, reduced node energy consumption, and node load balancing. Among them, the reliability of message forwarding in the network is the main design goal.

In the publish/subscribe system, the receivers of each perceived message cannot be determined beforehand. Therefore, most of the existing publish/subscribe data transmission protocols are based on broadcasting strategy, and some optimization measures are adopted to reduce the amount of data forwarding. For the dissemination of published messages, more optimization measures are adopted to check whether the subscribers are interested in this perceived message at the cluster head; when the cluster head receives the published message, it judges whether the subscribers are interested by the coverage relationship between the published message and the subscribed message.

Define the matching function f as shown in formula (1)

f (E) = {\begin{matrix} false (λ \leftarrow PRBT - Match (E)) = Ø \\ true (λ \leftarrow PRBT - Match (E)) \neq Ø \end{matrix}

(1)

where $λ$ represents a subscription set that matches the published message E. PRBT denotes a Predicate Relation Binary Tree, which is a binary tree composed of content predicates. Match(E) denotes a matching operation for issuing a message E on the binary tree. Make $D (λ)$ the downstream set of cluster head corresponding to the subscription. If $f (E) = false$ , it indicates that no subscription matches the published message E, thus E is overwritten. If $f (E) = true$ , it indicates that there is a subscription matching E, and the matching publication message E is forwarded by the forwarding function r. The definition of forwarding function r is shown in formula (2)

r (E) = {\begin{matrix} \forall vif \in (D (λ) - vi f_{θ}), send (E) \nabla (vi f_{θ}) \\ \forall vif \in D (λ), send (E) Δ (vi f_{θ}) \end{matrix}

(2)

where $vi f_{θ}$ represents downstream and upstream virtual nodes sent to E. Also, $\nabla (vi f_{θ})$ and $Δ (vi f_{θ})$ parameters represent E receiving from downstream and upstream virtual nodes, respectively.

The routing algorithm for publishing messages is shown in Algorithm 2. When the cluster head node receives the publish message, it checks whether the message already exists and ignores the message if it already exists, otherwise saves the message. If the message comes from a downstream cluster head, it is broadcast to the upstream cluster head set. Otherwise, the message is broadcast to the downstream cluster head set.

Algorithm 2. Publish message algorithm
Input: Message E Output: Whether to forward E 1: if Message E already exists or is invalid then 2: Overwrite message E without forwarding; 3: else 4: Aggregate message E with existing data; 5: Forwarding the message; 6: end if 7: if Publish messages from downstream cluster headers $D (λ)$ then 8: for each $vif$ , $vif \in (D (λ) - vi f_{θ})$ 9: $send (E, Δ (vi f_{θ}))$ ; 10: E is forwarded to the upstream cluster head; 11: end for 12: else 13: for each $vif$ , $vif \in D (λ)$ 14: $send (E, \nabla (vi f_{θ}))$ ; 15: E is forwarded to the downstream cluster head; 16: end for 17: end if 18: end

Algorithm 2. Publish message algorithm

Input: Message E
Output: Whether to forward E
1: if Message E already exists or is invalid then
2: Overwrite message E without forwarding;
3: else
4: Aggregate message E with existing data;
5: Forwarding the message;
6: end if
7: if Publish messages from downstream cluster headers

D (λ)

then
8: for each

vif

vif \in (D (λ) - vi f_{θ})

send (E, Δ (vi f_{θ}))

;
10: E is forwarded to the upstream cluster head;
11: end for
12: else
13: for each

vif

vif \in D (λ)

14:

send (E, \nabla (vi f_{θ}))

;
15: E is forwarded to the downstream cluster head;
16: end for
17: end if
18: end

Content matching algorithms

Content matching in publish/subscribe system mainly has two modes: centralized matching mode and distributed matching mode. Centralized matching mode is usually set up with a central server in the network. Subscribers send subscription messages to the central server for registration. Publishers also send publication messages to the central server for registration. After the central server receives the publication messages, it will automatically find out which among the subscribers meet the matching criteria in the cache. When the matching subscribers are found, the publishers will also send the published messages to the relevant subscribers.

There is no need to set up a central server in the distributed matching mode; however, some distributed nodes in the network act as the proxy. Subscribers broadcast the subscription messages to the network, and the proxy nodes in the network store the subscription information. Publishers also broadcast messages to the network. Subscription information and publication information are matched on the proxy nodes. If the matching is successful, the detailed information needed by subscribers is sent to the nodes. In this way, the matching calculation between subscription and publication messages is completed by the agent nodes distributed in the network, and no special central node is needed.

Due to the characteristic ease of failure and random distribution of sensor nodes, centralized matching mode is not suitable in this scene, but distributed matching mode can be adopted. In this article, the cluster head node is set as a local center node to avoid wasting too much energy in matching calculation for all nodes.

After receiving the publish message $Pu b_{e}$ , the sensor node matches the coverage according to the relation structure of the maintained subscription. It then gets the set of forwarding nodes according to the matching result and sends $Pu b_{e}$ to each node in the set of forwarding nodes one by one. A description of the content matching is shown in algorithm 3.

Algorithm 3. Content matching
Input: Message $Pu b_{e}$ Output: Whether to forward $Pu b_{e}$ 1: Receiving Published Messages from Upstream Nodes $Pu b_{e}$ ; 2: Matching $match (Pu b_{e}, Tre e_{S})$ ; 3: Query the routing table entries and get the set $C_{port}$ of nodes that $Pu b_{e}$ will forward; 4: if $C_{port} = Ø$ then 5: $Pu b_{e}$ is overwritten without any forwarding; 6: else 7: Forwarding $Pu b_{e}$ to each node in $C_{port}$ ; 8: end if 9: end

Algorithm 3. Content matching

Input: Message

Pu b_{e}

Output: Whether to forward

Pu b_{e}

1: Receiving Published Messages from Upstream Nodes

Pu b_{e}

;
2: Matching

match (Pu b_{e}, Tre e_{S})

;
3: Query the routing table entries and get the set

C_{port}

of nodes that

Pu b_{e}

will forward;
4: if

C_{port} = Ø

then
5:

Pu b_{e}

is overwritten without any forwarding;
6: else
7: Forwarding

Pu b_{e}

to each node in

C_{port}

;
8: end if
9: end

Unsubscribe message algorithm

Suppose subscriptions are sent upstream in the order of S₁, S₂, S₃, and S₄, and there is an ordering relation: S₂ → S₁, S₃ → S₁, and S₄ → S₃. The upstream cluster heads will maintain the subscription relation structure as shown in Figure 3. If node C₄ sends an unsubscribe operation $Cal (S_{4})$ to upstream cluster head R₂, content cluster head R₂ will determine whether to allow unsubscribe and whether to send an unsubscribe message to upstream cluster head (such as R₃). If subscription S₄ is still retained on the upstream content cluster head, the unsubscribe message must be sent again to the upstream content cluster head.

Figure 3.

Unsubscribe scheme.

In order to better support unsubscribe function, a flag is needed for each sending to the upstream cluster head to indicate whether the subscription exists in the upstream cluster head.

As shown in Figure 3, after the unsubscribe operation is performed on the cluster head, it is necessary to check whether the upstream cluster head has the same copy or has not been unsubscribed. If the same copy still exists on the upstream cluster head, it must also be sent upstream, so that the upstream cluster head can perform the unsubscribe operation. Otherwise, the higher the cluster head, the more information that has already been unsubscribed will be accumulated. This situation is described as follows:

S ₄ and S₃ are sent to the upstream in sequence. Due to the relation S₄ → S₃, the upstream cluster heads will maintain the relation structure. If only the lowest cluster head performs the unsubscribe operation when subscribing to S₄, the S₄ maintained by the upstream cluster heads will remain in the cluster head forever and become the real “garbage” information. The description of the unsubscribe process is shown in Algorithm 4. After receiving the unsubscribe message from the downstream node, the cluster head updates the subscription relationship structure and the routing table information and forwards the message to the upstream cluster head set.

Algorithm 4. Unsubscribe message algorithm
Input: Message $Cal (S)$ Output: Updated message $Cal (S')$ ; 1: Receiving unsubscribed messages from downstream nodes $Cal (S)$ ; 2: Update Subscription Relation Structure; 3: Update routing table entries; 4: if forward $Cal (S)$ to the upstream cluster head then 5: Update unsubscribe expression $S \to S'$ ; 6: Send $Cal (S')$ to upstream cluster head; 7: end if 8: end

Performance analysis and simulation

Performance analysis

Definition 1: Set the subscription size to $G$ , $\sum_{α} = {S | S \in Γ \land (\exists S^{'} (S \to S^{'}))}$ , $\sum_{β} = {S | S \in Γ \land (\neg \exists S^{'} (S \to S^{'}))}$ , and satisfy $\sum_{α} \cup \sum_{β} = Γ \land \sum_{α} \cap \sum_{β} = Ø$ , $| \sum_{α} |$ and $| \sum_{β} |$ as the number of elements in the set. Coverage ratio $α_{β} = | \sum_{α} | : | \sum_{β} |$ refers to the ratio between the number of overwritten subscriptions $α$ and the number of overwritten subscriptions. This ratio represents the coverage of the relation between subscriptions $β$ .

Theorem 1

The closer the cluster head node (layer 0) is to the core cluster head, the smaller the subscription size is maintained.

Proof

Assume that each cluster sends a subscription. Then, the subscription size of each content cluster head in Layer $H - 1$ is n and that of the content cluster head in Layer $L (0 \leq L \leq H - 1)$ is formula (3)

V (L) = n \cdot {(\frac{1}{α_{β} + 1})}^{H - L - 1} \cdot m^{H - L - 1}

(3)

It can be seen that the function V(L) in formula (3) is incremental for L.

Therefore, the closer to the node of the core cluster head (layer 0), the smaller the subscription size maintained.

Theorem 2

When $α_{β}$ value is larger, the subscription size of content cluster head maintained is smaller, and the total subscription size of the system is smaller.

Proof

Assume that each cluster sends a subscription. The subscription size of each content cluster head in H1 layer is n and that of the content cluster head $R_{L}$ in $L (0 \leq L \leq H - 1)$ layer is formula (4)

V_{L} (α_{β}) = n \cdot {(\frac{1}{α_{β} + 1})}^{H - L - 1} \cdot m^{H - L - 1}

(4)

Obviously, $V_{L} (α_{β})$ is a monotonic decreasing function about $α_{β}$ . The larger the value of $α_{β}$ , the smaller the subscription size maintained on the intermediate content cluster head $R_{L}$ . The total subscription size of the system is represented by formula (5)

\begin{matrix} V_{total} (α_{β}) = \sum_{i = 0}^{H - 1} (m^{i} \cdot V_{i} (α_{β})) \\ = \sum_{i = 0}^{H - 1} {m^{i} \cdot n \cdot {(\frac{1}{α_{β} + 1})}^{H - i - 1} \cdot m^{H - i - 1}} \end{matrix}

(5)

Let $= 1 / (α_{β} + 1)$ , which is substituted and simplified to obtain formula (6)

V_{total} (α_{β}) = n \cdot m^{H - 1} \cdot \sum_{i = 0}^{H - 1} X^{H - i - 1}

(6)

Formula (7) is used for further checking

V_{total} (α_{β}) = n \cdot m^{H - 1} \cdot \frac{1 - X^{H}}{1 - X}

(7)

Due to $0 < X = 1 / (α_{β} + 1) < 1$ , when $H \to \infty$ , $V_{total} (α_{β}) \to (n \cdot m^{H - 1}) / 1 - X$ , and V_total(α_β) decreases with respect to $α_{β}$ . With the increase in $α_{β}$ value, the total subscription size that is maintained by the system decreases.

Theorem 3

The larger the value of $α_{β}$ , the shorter the total routing time for published event matching.

Proof

Assume that the message transmission time between nodes in the topological network is constant c, and the total routing time of event message from the publishing cluster head to the matching subscription cluster head at the other end is $ϕ (α_{β})$ .

From formula (3), the subscription size $V_{L} (α_{β}) = n \cdot (1 / (α_{β} + 1))^{H - L - 1} \cdot m^{H - L - 1}$ on the L level content cluster head can be obtained. Assuming that the predicate-covering relation tree with $\log_{2} V_{L} (α_{β})$ expectation height is constructed among the subscription events on each cluster head, the matching time is $O (min {V_{L} (α_{β}), Ω_{L} \log_{2} V_{L} (α_{β})})$ , in which $Ω_{L}$ is the number of matching events on the L-level content cluster head.

The total routing time $ϕ (α_{β})$ is the sum of the total transmission time of messages on the internode links and the time spent matching event messages on the content cluster head, which is represented by formula (8)

\begin{matrix} ϕ (α_{β}) = 2 \\ \cdot {\sum_{i = L + 1}^{H} t (N_{H + L - i + 1}, N_{H + L - i}) + \sum_{i = L}^{H - 1} O (T_{i} (α_{β}))} \end{matrix}

(8)

For the link message transmission time of $t (x, y)$ , adjacent nodes and constant c, and $T_{i} (α_{β}) = min {V_{i} (α_{β}), Ω_{i} \log_{2} V_{i} (α_{β})}$ , formula (5) is substituted to obtain formula (9)

\begin{matrix} ϕ (α_{β}) = 2 c \cdot (H - L) + 2 \cdot \sum_{i = L}^{H - 1} \\ O (min {V_{i} (α_{β}), Ω_{i} \log_{2} V_{i} (α_{β})}) \end{matrix}

(9)

Obviously, $ϕ (α_{β})$ is an incremental function of $T_{i} (α_{β})$ .

For $T_{i} (α_{β})$ , $T_{i} (α_{β})$ is an incremental function of $V_{i} (α_{β})$ . Theorem 2 shows that $V_{i} (α_{β})$ is incremental for $α_{β}$ , so $ϕ (α_{β})$ is an incremental function for $α_{β}$ .

In summary, with the increase in $α_{β}$ value, $ϕ (α_{β})$ value decreases; that is, the total routing time decreases.

Definition 2

Let the number of attributes (dimensions) of any subscription be d and the coverage ratio of attributes (dimensions) be $α_{β}^{i} (i \in [1, d])$ . The system subscription size based on overall subscription coverage technology is V(S), and the system subscription size based on event coverage technology is V(P).

Theorem 4

Coverage ratio based on global subscription decreases with the increase in attribute (dimension) d; when d > 1, V(P) < V(S).

Proof

Assuming that based on the coverage ratio $γ (d)$ of the whole subscription, the probability of coverage subscription is $ρ (d)$ . Then, $ρ (d) = \prod_{i = 1}^{i \leq d} (α_{β}^{i} / (1 + α_{β}^{i}))$ , $ρ (d)$ is decreasing for dimension d, so $γ (d) = ρ (d) / (1 - ρ (d))$ , and $γ (d)$ is an incremental function of $ρ (d)$ .

Then, we can see that $γ (d)$ is a decreasing function of dimension d. It can be seen that the coverage ratio $γ (d)$ based on global subscription decreases with the increase in attribute dimension d.

Taking subscription events as the basic unit for calculating subscription size, formula (10) can be obtained from formula (9)

\begin{matrix} V (S) = d \cdot n \cdot m^{H - 1} \frac{1 - {(1 - ρ (d))}^{H}}{ρ (d)} and V (P) \\ = \sum_{i = 1}^{i \leq d} {n \cdot m^{H - 1} \cdot \frac{1 - {(\frac{1}{α_{β}^{i} + 1})}^{H}}{1 - (\frac{1}{α_{β}^{i} + 1})}} \end{matrix}

(10)

$Let 0 < χ_{i} = \frac{1}{1 + α_{β}^{i}} < 1, then ρ (d) = Π_{i = 1}^{i \leq d} (1 - χ_{i})$

Because $χ_{i} = {\begin{matrix} < 1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}) d > 1 \\ = 1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}) d = 1 \end{matrix}$ , so when d > 1, there is a formula (11)

\frac{V (P)}{V (S)} = \frac{\sum_{i = 1}^{i \leq d} {\frac{1 - {(χ_{i})}^{H}}{1 - χ_{i}}} < \sum_{i = 1}^{i \leq d} {\frac{1 - {(1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}))}^{H}}{1 - (1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}))}}}{d \cdot \frac{1 - {(1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}))}^{H}}{1 - (1 - Π_{i = 1}^{i \leq d} (1 - χ_{i}))}} < 1

(11)

That is, V(P) < V(S).

The above theorem shows that the larger the coverage relationship, the smaller the subscription size and the shorter the total routing time of matching event messages. Event coverage technology based on smaller granularity is the reason to improve the overall performance of the system by increasing coverage ratio $α_{β}$ .

The randomness of cluster head event subscription has some influence on the performance of publish/subscribe system. Set the subscription size $R_{i}$ to $G_{R_{i}}$ and coverage ratio to α_β. According to the selective forwarding strategy, the best case is that $R_{i}$ only needs to forward $G_{R_{i}} \cdot (1 / (1 + α_{β}))$ subscriptions to the upstream cluster head $R_{i - 1}$ . However, the performance of the system will be degraded when there are overlaid subscriptions sent to the upstream cluster before the overlaid subscriptions. The worst case is that $R_{i}$ still needs to forward $G_{R_{i}}$ ’s subscriptions to $R_{i - 1}$ . It can be known that the subscription size maintained on $R_{i - 1}$ of each cluster head in publish/subscribe system is in the range $G_{R_{i}} \cdot (1 / (1 + α^{β})) ~ G_{R_{i}}$ .

For subscription size $G$ , assume that the test data are evenly distributed. The spatial complexity of the publishing algorithm and the subscription algorithm are the same, which is O( $G$ ). For the subscription algorithm, the computation complexity of the insert operation is O(1), and the average computation complexity for searching for insertion locations is O( $G$ ). For the unsubscribe algorithm, the delete operation complexity is O(1). The average computation complexity for searching for deleted location points is O( $G$ ). Time complexity of content matching algorithm is O( $G$ ). In summary, the computation complexity of the proposed method is O( $G$ ).

Simulation and results

The performance of data transmission method in publish/subscribe mode is analyzed in this section, and hence, the characteristics of our proposed method are illustrated by comparing with several existing methods through simulations.

To verify the capability of the proposed RPCP algorithm, we performed simulation to compare its performance with two publish/subscribe messaging algorithms: PSM¹⁵ and CETP.¹⁷ In the simulation, we used MATLAB as the simulation software. We also assumed that there are 200 nodes in MSNs, and the nodes are randomly distributed in the area with radius of 200 m. The various parameters we set for the simulation are presented in Table 1.

Table 1.

Simulation parameters.

Parameter name	Numerical value
Network area	A circular region with a radius of 200 m
Number of nodes	200
Initial energy of nodes	1 J
Sending data consumption	20 nJ
Received data consumption	10 nJ
Data matching consumption	10 nJ
Packet size	1000 bits
Cluster head ratio	5%

In this investigation, three groups of simulations are carried out to analyze and compare the event matching time and the successful subscription time for different scale of published events. In order to reduce the impact of random events on the simulation results, each group of simulations was performed five times, and the arithmetic mean of the five times was taken as the basis for comparison.

Simulation 1: The impact of publication size on subscription success time

Subscription success time is the time it takes a subscriber to send a subscription message to the network and to receive matching awareness data. Generally speaking, the larger number of published event content to be processed, the longer the processing time of the algorithm. This consequently increases the time of event transmission to subscribers, thus affecting the efficiency of event processing. Simulation 1 compares the average time required for subscribers to successfully receive published events. We performed the simulation using three publish/subscribe messaging algorithms with varying numbers of published events.

The data curves in Figure 4 show that the receiving time of RPCP algorithm increases slowly, and CETP algorithm is close to RPCP algorithm in terms of average receiving time performance. The PSM algorithm is mostly affected by the size of the publication. When the number of publications is less than 800, its performance is close to or even better than RPCP algorithm. When the number of publications is more than 800, the average receiving time sharply increases. The RPCP algorithm uses the cluster head to deliver the publish and subscribe messages, which can effectively reduce the number of times the message is forwarded, so that the time for obtaining the subscription result is shorter.

Figure 4.

Comparison of average receive time at different number of published events.

Simulation 2: The impact of published scale on network lifetime

When there are more events in the network, the energy of nodes will be exhausted quickly, resulting in network holes, and the rate of packet loss in data transmission will increase. The network is considered dead when the packet loss rate reaches a specified threshold. Figure 5 compares the network lifetime of the three publish/subscribe messaging algorithms under different number of events.

Figure 5.

Comparison of network lifetime at different number of published events.

Figure 5 shows that the decline in the network lifetime of RPCP is gradual as the number of published events increase, and it has the longest network lifetime for almost all published events sizes. It can be seen from Figure 6 that the network life of the proposed method is higher than the other two methods when the nodes are denser. For example, when there are 50 published events, the network life of the three methods is not much different, and when there are 800 published events, the RPCP method is 54% longer than CETP and 28% longer than PSM. CETP has the fastest decline in network lifetime due to the need to maintain the community structure for more communications. The RPCP algorithm sets a reasonable number of cluster heads and allows the cluster head to periodically rotate, thereby reducing the energy consumption of the entire network and improving the survival time of the network.

Figure 6.

Comparison of energy consumption at different number of published events.

Simulation 3: The effect of the published scale on energy consumption

As shown in Figure 6, the three methods will increase the energy consumption with the number of published events increasing. The CETP method consumes more power because each message needs to be negotiated multiple times with neighboring nodes before transmission. When the message in the message queue is full, the old message in the queue needs to be deleted so that we can receive new messages. The PSM policy only uses the distance value of the message as a reference for the transmission cost. Therefore, as long as the short-distance message, it can replace the long-distance message. Meanwhile, the method does not consider whether the message is a useful message, which may cause a large amount of invalid data to be forwarded and meaninglessly consume network energy. For sensor nodes, the most energy is consumed when sending and receiving data. The RPCP method proposed in this article filters the publishing and subscription information, thus effectively reducing the amount of information that needs to be transmitted in the network, thus effectively reducing the network energy consumption.

Simulation 4: The effect of the published scale on success rate

As can be seen from Figure 7, since the method proposed in this article allows the cluster head node to play the role of information matching and better save energy, as the number of events in the network increases, the subscription success rate decreases slowly. The cluster head nodes in the network adopting the RPCP method have the matching function of publishing and subscribing messages, so that a high success rate can be maintained. When the number of published messages is large, the message growth in the network may cause delay and loss, resulting in a decrease in subscription success rate. However, the method proposed in this article is the slowest decline and remains above 80%, because the selective forwarding of messages by the cluster head node effectively reduces the amount of communication in the network.

Figure 7.

Comparison of success rate at different number of published events.

Conclusion

This article first summarizes the concept and characteristics of publish/subscribe system and then introduces the research status of using publish/subscribe system in sensor networks. By using existing clustering routing protocols, cluster head nodes are defined as message agents in publish/subscribe systems to collect and match publish and subscribe information. The basic idea of content-based publish/subscribe system is elaborated in detail. The publish event algorithm, subscribe event algorithm, content matching algorithm, and unsubscribe event algorithm involved in the system are elaborated in detail. The implementation algorithm is given. The effectiveness of the method is proved by performance analysis and simulations.

Footnotes

Handling Editor: Zhong Shen

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This work is partly supported by National Natural Science Foundation of China (NSFC grant numbers: U1836116), the project of Jiangsu provincial Six Talent Peaks (Grant numbers: XYDXXJS-016), and Open Project Program of Jiangsu Key Laboratory of Security Tech. for Industrial Cyberspace (Grant numbers: STICB201905).

ORCID iD

Lin Lin

References

Sujeethnanda

Nayak

Ramamurthy

. A novel approach to an energy aware routing protocol for mobile WSN: QoS provision. In: International conference on advances in computing & communications, Cochin, India, 9–11 August 2012, pp.38–41. New York: IEEE.

Zhou

Yang

Sun

, et al. A novel wireless mobile platform to locate and gather data from optical fiber sensors integrated into a WSN. IEEE Sens J 2015; 15(6): 3615–3621.

Guerroumi

Pathan

ASK

. Hybrid data dissemination protocol (HDDP) for wireless sensor networks. Wirel Netw 2018; 24: 1739–1754.

Kung

Chen

, et al. An intelligent slope disaster prediction and monitoring system based on WSN and ANP. Expert Syst Appl 2014; 41(10): 4554–4562.

Liu

. Battlefield awareness network research based on intelligence role division and wireless sensor network. Appl Mech Mater 2013; 300–315: 580–584.

Adelinesneha

Chakravarthi

Glenn

. A review on energy efficient image feature transmission in WSN for micro region pest control. In: International conference on electrical, electronics, and optimization techniques, Chennai, India, 3–5 March 2016, pp.4859–4862. New York: IEEE.

Eugster

Felber

Guerraoui

, et al. The many faces of publish/subscribe. ACM Comput Surv 2003; 35(2): 114–131.

Carzaniga

Papalini

Wolf

. Content based publish/subscribe networking and information centric networking. In: ACM SIGCOMM workshop on information centric networking, Toronto, ON, Canada, 19 August 2011, pp.212–225. New York: ACM.

Ming

Fan

Kim

, et al. A scalable and elastic publish/subscribe service. In: IEEE international parallel & distributed processing symposium, Anchorage, AK, 16–20 May 2011, pp.1297–1314. New York: IEEE.

10.

Liu

Seet

. Optimal network structuring for large scale WSN with virtual broker based publish/subscribe. In: Workshop on recent trends in telecommunications research, Palmerston North, New Zealand, 10 February 2017, pp.64–68. New York: IEEE.

11.

Sheltami

Al-Roubaiey

Mahmoud

, et al. A publish/subscribe middleware cost in wireless sensor networks: a review and case study. In: IEEE 28th Canadian conference on electrical and computer engineering, Halifax, NS, Canada, 3–6 May 2015, pp.1356–1363. New York: IEEE.

12.

Burcea

Jacobsen

De Lara

, et al. Operation in publish/subscribe middleware. In: Proceedings of the 5th IEEE international conference on mobile data management, Berkeley, CA, 19–22 January 2004, pp.39–51. New York: IEEE.

13.

Muthusamy

Petrovic

Jacobsen

. Effects of routing computations in content based routing networks with mobile data sources. In: Proceedings of the ACM international conference on mobile computing and networking, Cologne, 28 August–2 September 2005, pp.39–50. New York: ACM.

14.

Leyva-Mayorga

Rivero-Angeles

Carreto-Arellano

, et al. QoS analysis for a nonpreemptive continuous monitoring and event-driven WSN protocol in mobile environments. Int J Distrib Sens N 2015; 11(3): 457–473.

15.

Tekin

Sahingoz

. A publish/subscribe messaging system for wireless sensor networks. In: 6th international conference on digital information & communication technology & its applications, Konya, 21–23 July 2016, pp.171–176. New York: IEEE.

16.

Chapuis

Garbinato

Mourot

. A horizontally scalable and reliable architecture for location based publish subscribe. In: IEEE 36th symposium on reliable distributed systems, Hong Kong, China, 26–29 September 2017, pp.74–83. New York: IEEE.

17.

Liu

Zhu

, et al. A community based event delivery protocol in publish/subscribe systems for delay tolerant sensor networks. Sensors 2009; 9(10): 7580–7594.

18.

Fan

Xinming

Lei

, et al. Network coding-based flooding with a mobile sink in low-duty-cycle wireless sensor networks. IEEE T Mobile Comput 2018; 18: 1857–1869.

19.

Ganala

. Mobile sensor nodes scheduling for bounded region coverage. Wirel Netw 2018; 25: 2157–2171.

20.

Kumar

Tarachand

Annavarapu

CSR

. ACO-based mobile sink path determination for wireless sensor networks under non-uniform data constraints. Appl Soft Comput 2018; 69: 528–540.

21.

Yick

Mukherjee

Ghosal

. Wireless sensor network survey. Comput Netw 2008; 52(12): 2292–2330.

22.

Sinha

. Performance evaluation of data aggregation for cluster based wireless sensor network. Hum Centri Comput Inf Sci 2013; 3(1): 13.

23.

Abushiba

Johnson

Alharthi

, et al. An energy efficient and adaptive clustering for wireless sensor network (CH leach) using leach protocol. In: International computer engineering conference, Cairo, Egypt, 27–28 December 2018, pp.50–54. New York: IEEE.