Enabling Publish/Subscribe Services in Sensor Networks

36

Enabling Publish/Subscribe Services in SensorNetworks

Duc A. Tran1 and Linh H. Truong2

1University of Massachusetts, Boston, USA2IBM Zurich Research Laboratory, Switzerland

36.1 Introduction

We have seen in this decade sensor technologies increasingly deployed inmany applications. Sensors are used to monitor the surrounding environmentfor important events such as climate changes, chemical leaks, early warningsof a natural disaster, or violations in a no-trespassing zone. For a large areabeing monitored, we need a sensor network that allows for efficient searchand dissemination of the sensor data.

A sensor network for monitoring purposes basically involves two types ofnodes: the “query" nodes and the “sensor" nodes. The query nodes are thosethat send queries into the network to inquire about sensor data of interest.A query node can be a sink node that needs to collect the data from thenetwork or an actuator node whose operation is triggered based on eventsdetected in the network. The sensor nodes are those that capture event dataand need to send them, or notify of their existence, to interested query nodes.In many applications, a query needs to be submitted to the network in advancewaiting for notification of the events that match the query. Because a sensornode does not know who may be interested in its data, and, viceversa, aquery node does not know where in the network its events of interest mayoccur, a challenging problem is to design an effective mechanism for querysubscription and the event notification so that an event can notify its inquirersquickly and efficiently. In this publish/subscribe problem, the sensor nodes

2 Enabling Publish/Subscribe Services in Sensor Networks

and query nodes are respectively called thepublishernodes andsubscribernodes.

Many Internet-based publish/subscribe systems have been designed, e.g.,PADRES [24], REBECA [25], SIENA [12], and XNET [14]. Some conceptsof these systems might be useful, but enabling publish/subscribe services insensor networks is fundamentally different due to unique constraints on com-munication, storage, and computation capacities. On the other hand, despite alot of research and development efforts made for sensor networks that providesearch mechanisms, most of them are focused on retrieving sensor data thathavealreadybeen stored by the network. The publish/subscribe model posesa different challenge as a query of this model is to inquire about futureevents.Thus, the query must be stored proactively in the network to wait for thoseevents. When such an event occurs, it needs to be published tothe networkto search for the matching queries among the stored. With the“proactive"storing of queries, events can be delivered “timely" to the subscribers, whilein the “retrieving" case, subscribers only receive “past" events. This is ofimportance to applications that require a real-time monitoring of the events.

To enable publish/subscribe services in sensor networks, adesirable de-sign should consider the following important issues:

• Routing design: To subscribe a query, without any knowledgeaboutwhere a matching event could occur, the simplest way is to broadcastit to the entire network. This way, an event can find its matching queriesimmediately at the local node. Because the traffic due to broadcastingcan be overwhelming for a large-scale network, other efforts have beenattempted to reduce this communication with an efficient routing design.A key approach is to replicate a query to a set of select nodes and topublish an event to another corresponding set of select nodes such that, ifthe event matches the query, there exists a rendezvous node,certainly orat least with a high probability. This guarantee needs to take into accountthe communication cost due to transmissions of queries and events.

• Query aggregation: Because a sensor node’s storage capacity is usuallylimited, it is desirable that a node stores as small a number of queries aspossible. The broadcast approach aforementioned incurs a high storagecost because each node has to store every query. It is thus importantto reduce the number of replicas for any given query. By doingso, italso helps reduce the amount of traffic in the network due to query for-wardings. Query aggregation serves this purpose. For example, queriescan be merged to produce fewer queries. Or, if a new query arrives at

36.2 Preliminaries 3

a node finding itself covered by a locally stored query, the new querymay not necessarily be forwarded further. This is so becauseany eventmatching the new query will match the existing query as well,and thusthis event will be returned anyway as a result of the existingquery’searlier subscription.

• Event matching: When a node receives a publication of an event, thenode may need to evaluate its locally stored queries to find those match-ing the event. Because a sensor node has limited processing capability,this procedure if not properly designed may create a computational bur-den too heavy for the node. Several techniques have been proposed toorganize the queries into some indexing architecture that is convenientfor event matching. Alternatively, one may employ a multi-phase check-ing algorithm where the earlier phases are to determine quickly whethera query should be ignored and the later phases are to evaluatethe queriesthat pass the earlier phases.

While most techniques emphasize the above algorithmic issues, e.g., [34,31, 22, 40, 48, 16, 27, 49], publish/subscribe middleware techniques aimedat high-level service abstraction have also been proposed [44, 33, 28, 52].They provide a convenient middleware layer serving as an APIfor the ap-plication developer, hiding all the underlying network complexities and theimplementation details of the publish/subscribe mechanisms.

A survey of representative publish/subscribe techniques for sensor net-works is presented in this chapter, with attention given to the issues of routingdesign, query aggregation, event matching, and middlewaredevelopment.

36.2 Preliminaries

36.2.1 Event and Query Representation

An event in a publish/subscribe system is usually specified as a set ofdattribute-value pairs {(attr1, v1), (attr2, v2), ..., (attrd,vd)} where d is thenumber of attributes,{attr1,attr2, ...,attrd}, associated with the event. Forexample, if the sensor network is used to monitor temperature, humidity, windspeed, and air pressure of some area,d is four – representing these four sensordata attributes.

The constraints in a query, in general, can be specified in a predicate ofthe disjunctive normal form – a disjunction of one or more condition clauses,each clause being a conjunction of elementary predicates. Each elementarypredicate, denoted by(attri γ pi), is a condition on some attributeattri with γ


being the filtering operator. A filtering operator can be a comparison operator(one of {=, <, >}) or a string operator such as“prefix of", “suffix of", and“substring of" if the attribute is ofstring type. However, for simplicity ofimplementation, most schemes assume that a query is a singleconjunctiveclause of elementary predicates that can only use the comparison operators.This form of query can be called therectangular formbecause if an event ismodeled as a point in ad-dimensional coordinate system, each dimensionrepresenting an attribute, a query can be considered ad-dimensional boxwith the vertices defined based on the attribute constraint values providedin the query clause. Sometimes it can be a tedious process to specify all thelower and upper bounds for all the attributes of a query. In such a case, itis more convenient to specify a query in terms of an event sample and askto be notified of all the events similar to this sample. For example, considera camera-sensor remote surveillance network deployed overmany airportsto detect criminal suspects. If a particular suspect is searched for, his or herpicture is submited as a subscription to the network in hopesof finding thelocations where similar images are captured. A query of thiskind can berepresented by a sphere, in which the sample is the center of the sphere andsimilarity is constrained by the sphere’s radius. This query is said to have thespherical form.

36.2.2 Subject-based vs. Content-based

There are two main types of publish/subscribe designs [20]:subject-based orcontent-based. In the subject-based design, events are categorized into a smallnumber of knownsubjects. There must be an event attribute called‘subject’,or something alike, that represents the type of the event anda query mustinclude a predicate(‘subject’ = s) to search only events belonging to someknown subjects. The occurence of any event of subjectswill trigger a notifi-cation to the query subscriber. The subscription and notification protocols aremainly driven by subject match rather than actual-content match.

The content-based design offers a finer filtering inside the network and aricher way to express queries. A subscriber wants to receiveonly the eventsthat match its query content, not all the events that belong to a certain subject(which could be too many). A node upon receipt of a query or event mes-sage needs to extract the content and makes a forwarding decision based onthis content. We can think of the subject-based model as a special case ofthe content-based model and because of this simplification,a subject-basedsystem is less challenging than a content-based system to design.

36.3 Routing Design 5

36.2.3 Sensor Network Assumptions

There are different types of sensor networks that have been considered byexisting publish/subscribe techniques. The techniques in[39, 40] assume thata sensor node knows its location (e.g., by a built-in GPS-like device or byrunning a localization protocol [47]). A mapping from the query/event spaceto the location space can be designed, based on which a query and a matchingevent are sent to the corresponding nodes who can find each other within ashort distance. For example, if a query is replicated at all the nodes alongthe vertical line crossing the subscriber node’s location,and if an event ispublished to all the nodes along the horizontal line crossing the publishernode’s location, a rendezvous node exists for every pair of queries and events.This is so because every vertical line must meet every horizontal line.

Several techniques do not require any knowledge of locationinforma-tion (e.g., [34, 31, 16, 45, 27, 49]). Besides the broadcast approach, anotherapproach used by such techniques is based on some form of randomizeddissemination to subscribe a query or publish an event. The main intuitionis that if a query is replicated to a set of random nodes, an event published toits corresponding set of also random nodes, and if these two sets are largeenough, then there exists a rendezvous node with a high probability. Forexample, one can use a random walk or a gossip-based protocol[16, 45] tovisit these large sets of nodes. Some other techniques [27, 49] use a namingscheme to assign names to the network nodes and routing is driven by nodenames instead of nodes being chosen in random.

Most techniques assume that nodes are stationary. There aresome tech-niques addressing publish/subscribe in general mobile networks that couldapply to a mobile sensor network [4, 53, 26, 23, 32, 18, 15]. This chapterdiscusses techniques designed for stationary networks only.

36.3 Routing Design

Routing protocols for query subscription and event notification form the mostimportant component of any distributed publish/subscribesystem. While tra-ditional routing protocols for sensor networks are designed for synchronouscommunication and are address-driven, routing for publish/subscribe pur-poses is asynchronous because subscribers and publishers are not aware ofeach other and the timing of the subscription and publication. There arevarious publish/subscribe routing approaches which are discussed below.


36.3.1 Centralized-based

A simple approach is to employ a central brokerage station that receives thesubscription of every query and publication of every event.This approachkeeps the system design lightweight on each node. Routing ofqueries andevents becomes trivial because the central broker is the only destination.Queries may be aggregated at the intermediate nodes on the way to the cen-tral broker. Event matching is conducted at the central broker to find all thequeries matching a newly published event. The centralized-based approach,which has been implemented in the MQTT and MQTT-S middlewareat IBM[33], can work with queries and events of any form. However, the centralbroker can easily be a severe communication bottleneck if queries and eventsare produced at high rates.

36.3.2 Broadcast-based

Directed Diffusion [34] is one of the earliest publish/subscribe techniques forsensor networks. Given a new query, the first step in this technique is forthe subscriber node to broadcast the query to all the nodes inthe network.Each node upon receipt of this query creates a “gradient" entry in the routingtable to point toward the neighboring node from which the query is received.Using a gradient path, a matching event can be sent toward thesubscriber.Since there may be more than one such gradient path, the choice of whichpath to use is made based on some performance factors to improve energyefficiency.

[31] proposes building a broadcast tree, called PST, spanning all the nodesin which events will be disseminated from a publisher (root node) to all theirsubscribers. Each node in PST that has a subscription needs to let its parentnode know of this subscription. Thus a node can compute a combination ofall the subscriptions downstream. When an event is published by the root,the event will follow the branches of PST that lead to all the matching sub-scribers. If there are multiple publishers, multiple treesare built each for apublisher, or alternatively, a shared root is selected thatreceives all the eventsfrom the publishers and a single tree is built based on this root to send theevents to all the nodes. PST does not incur the cost to replicate queries at ev-ery node, but it is efficient only when there are a smaller number of publishernodes.

In a different effort, [41] proposes a hierarchical structure to organize thenetwork into multiple clusters, in which each cluster formsa publish/subscribesub-network and has a representative node to appear in the next layer of the


hierarchy; the representative nodes form a layer of clusters which again areused to build the next layer in the hierarchy. The representative nodes areresponsible for forwarding a query or event from one sub-network to another.Although this clustering idea can potentially reduce the subscription andnotification traffic in the network compared to the pure broadcast-based ap-proach, its complexity lies in the maintenance of the hierarchy under networkdynamics.

36.3.3 Location-based

Flooding the network can be expensive, especially for systems where thereare a large number of queries and events generated by many potential sub-scriber and publisher nodes. Consequently, many distributed techniques havebeen proposed. If the location is known for every node, the location infor-mation can be useful. [39] proposed the method of GeographicHash Tables(GHT) – to hash the data space to locations in the location space. Each datavalue is respresented by an one-dimensional identifier called a “key"k, whichcorreponds to a geographic coordinateh(k) based on the hash function. Thus,if both events and queries each can be identified by a single key, we canuse GHT. For example, a subject-based system is a natural candidate for thistechnique because the subject value can be used as the key value for GHT. Aquery with keyk will be stored at the node closest to the locationh(k). Whenan event with the same keyk emerges, it will be routed to the nodeh(k)and thus can find its matching queries. For routing from a sensor location toanother sensor location, we can use a geographic routing protocol designedfor sensor networks such as [35]. An extension of the GHT technique incombination with landmark-based routing to improve routing efficiency isproposed in [22].

Another location-based technique called Double-Ruling isproposed in[40], in which each nodeP is mapped to a pointf (P) on the surface of a 3Dsphere and a keyk is hashed to a pointh(k) also on this spherical surface.A query with keyk subscribed by a nodeP will be sent to the node corre-sponding to the pointh(k). The routing follows the great circle connectingthe pointsh(k) and f (P) on the 3D surface. An event is published to thecorresponding node in a similar fashion and thus every eventwith key k willbe sent to nodeh(k) and can find all the matching queries there. A propertyof Double-Ruling is that it is distance-sensitive: the length of the notificationpath from a publisher to a matching subscriber is guaranteedto be within a


small constant factor of the direct path connecting them. The GHT methoddoes not make this guarantee.

The above distributed methods (GHT and Double-Ruling) should notwork efficiently with a content-based publish/subscribe system because itis difficult to represent a complex query by a single key. For events andqueries of any dimensionalityd, one can use the technique proposed by [48].This technique assumes the spherical form for the queries. Given a query, arandom-projection method is used to hash this query into a 2Drectangle inthe location space; the query will be replicated at all the nodes inside thisrectangle. Using the same random projection, an event is hashed a singlelocation; the event will be sent to the node closest to this location. The randomproject method guarantees that this event will find all the matching queries. Toreduce the number of query replicas, the subscription covering relationshipis taken into account to avoid further replications of thosequeries that aresubsumed by previously-subscribed queries.

36.3.4 Gossip-based

Without location information, a common idea is to use some form of gossip todisseminate queries and events. A simple design is to use random walks [3, 9].Each query is replicated on all the nodes visited by a random walk startingfrom the subscriber node, and each event also follows a random walk fromthe publisher node to find the queries. If these random walks are long enough,it is highly likely that an event will find all the matching queries. To shortenthe notification delay, multiple random walks can be used to propagate anevent (or to replicate a query) [9].

Another approach is proposed in [16], where both queries andeventsare “selectively" broadcast to the network. A query is broadcast to an extentdefined by the subscription horizonφ which limits the number of times thequery is rebroadcast. In the broadcast of an event, only a fraction τ of theneighbor links at each current node is used to forward the event. By choosingappropriate values forφ andτ , we can control the overhead and effectivenessof the system.

We can also design a publish/subscribe mechanism by adopting Bub-bleStorm – a gossip idea proposed in [45]: each query is replicated in arandom-walk based tree ofq = O(

√n) nodes rooted at the subscriber node,

and each event is sent along a similarly-built tree ofc2n/q nodes rootedat the publisher node wheren is the number of nodes andc ≥ 1 is a cer-


!

!

"#$

"!$

%!

"&$

%%!

"'$

!!

"($

!%!

")$

!%%!

"*$

%!!

"+$

%!%!

",$

%%!!

"!%$

!%%!!

"!'$

%%!%!

"!!$

!!!

"!#$

!%!!

"!&$

!%%!%!

"!($

%!!!

"!)$

%!!%!

"!*$

%!!%%!

"!+$

%!%!!

"!,$

%%!%!!

"#%$

%%!%!%!

"#!$

%!!!!

"##$

%!!%%!!

"#&$

%%!%!!!

"#'$

Figure 36.1 The Pub-2-Sub+ scheme: Nodes are each assigned a name and the names form aprefix tree. Solid-bold path represents the subscription path of query [‘0110001’, ‘0110101’]initiated by node 12; dashed-bold path represents the notification path of event ‘0110010’published by node 22

tainty constant. It is shown that the probability to have a rendezvous node isr = 1−exp(−c2) (e.g.,c = 2 means a hit probability ofr = 0.98).

36.3.5 Naming-based

Despite its simplicity, the gossip-based approach incurs significant commu-nication, storage, and computation costs because each query or event needsto be disseminated to many nodes to have a good chance to meet its matchesat rendezvous nodes. Also, the guarantee that a rendezvous node exists forevery pair of queries and events, including those that do notmatch eachother, is unnecesssarily strong and thus leads to unnecessary traffic. There-fore, alternative techniques that requires no location information but is notbased on gossiping are proposed [27, 49]. The common idea is to designa naming scheme that assignsnamesto the nodes in a way convenient forrouting purposes. The technique in [27] clusters the network into a multi-levelhierarchy and assigns to each node a name based on its position in this hier-archy. The resultant hierarchical naming scheme is used forrouting duringevent publication and query subscription. Each node requires onlyO(logn)bits per node to store auxiliary routing information. Any event can find itssubscribers in a distance-sensitive way. Further, by visiting only O(k) nodes,the subscriber can collect all occurrences of a particular type of data withina similarity radiusk (for spherical queries). The above technique works forthe subject-based model only. The Pub-2-Sub+ technique [49] is also based


on a naming scheme but designed for content-based services.Pub-2-Sub+

maintains a set ofmspanning trees each rooted at a node in the network. Theroot nodes are dedicated reliable nodes placed at random network positions.Each tree correponds to a naming tree assigning a binary-string name to eachnode; hence, a node hasm names. The names on a tree form a prefix tree.Based on the naming scheme, each node is assigned a “zone" of binary stringsto own. The zone of a node is the set of all binary strings starting with thisnode’s name but not with any child node’s name. A query is subscribed to arandom tree and an event is published to all the trees. Pub-2-Sub+ formatsan event as a binary string (e.g., ‘0110010’) and a query an interval of binarystrings (e.g., [‘0110001’, ‘0110101’]). On the randomly chosen tree, a queryis routed to, and stored at, all the nodes whose zone overlapswith the query’sinterval. On each tree, an event is published to the node whose name is thelongest prefix of the event string. Figure 36.1 provides an example wherem= 1. The query [‘0110001’, ‘0110101’] is stored at nodes 3, 8,17, and 18.The event ‘0110010’ is published to node 18; it will find all the matchingqueries there. In general, the notification path is bounded by two times thetree height which should beO(logn) in most cases. Also, because there aremultiple paths for the event notification, the disconnection of a path due tosome failure does not stop an event from finding its way to the matchingqueries.

36.4 Query Aggregation

Queries in a publish/subscribe system need to be stored in advance. Dueto the resource constraints of a typical sensor node, it is desirable to limitthe replication of each query in the network. Although the routing designdictates how to disseminate a query, its integration with a query aggregationmechanism may lead to more efficient query forwarding. Queries arriving ata node can be merged and/or pruned to produce fewer queries representingequivalent constraints. Query aggregation based on covering relationship isuseful to deciding whether a query needs to be forwarded further. This sectiondescribes some common aggregation strategies.

36.4.1 Subscription Covering

Used in various Internet-based publish/subscribe systems[24, 25, 12, 14],one strategy is that a node, upon receipt of a new subscription query, does notforward it if it is already covered by an existing locally stored query. Figure

36.4 Query Aggregation 11

Figure 36.2 Subscription Covering: Do not forward a new subscription s if it is alreadycovered by an existing subscriptionsi

36.2 illustrates this strategy. Typically, when a new querys is routed to anodeP, the node will store a copy of this query and forward it to the nextnodePnext according to the subscription’s routing protocol. When thenextnodePnext receives a publication of an eventx that matchess, it will forwardit back toP, which in turn forwardsx to the node that previously sents to P.Now, let us assume that there is an existing querysi stored atP such thatsi

coverss (i.e.,si ⊃ s). In this case,P may opt not to forwards to Pnext becauseP knows that if there is an eventx matchings, it must be returned toP as aresult ofP’s forwarding si earlier. By not forwardings, we avoid the costsof disseminatings further in the network and collecting duplicate events thatsatisfy bothsandsi .

Detecting coverings in a large set of queries can, however, be a compu-tationally expensive procedure for any given sensor node. On the other hand,it is not mandatory that covered queries must not be forwarded. Techniques[38, 43, 46] have been proposed to detectapproximatelysubscription cover-ings. Although such a technique may still forward a query even if the queryis covered by an existing one, it is guaranteed that no matching event will bemissed. These techniques are still much more efficient than having to detectall coverings.

The technique in [43] assumes that queries adopt the rectangular form. Itis observed that if we map a rectangular querys = [l1, r1]× [l2, r2]× ...×[ld, rd] into a 2d-dimensional pointp(s) = (−l1, r1,−l2, r2, ...,−ld, rd), the


subscription covering problem ind dimensions becomes the point dominanceproblem in 2d dimensions. A pointp is said todominatea point p′ if everycoordinate ofp is no less than that ofp′. Instead of solving this problemdirectly, [43] proposed to solve an approximate version of the problem:

“Find a data structure for a setΣ of n points in them-dimensional box[0,MAX1]× [0,MAX2]× ...× [0,MAXm] so that the following questioncan be answered efficiently: given a constantε ∈ (0,1), and a query pointp= (p1, p2, ..., pm), search a subset of the box[p1,MAX1]× [p2,MAX2]×...× [pm,MAX2], whose volume is at least(1− ε) of the volume of thebox, and report any point ofΣ if it is in the subset."

A data structure was proposed that sorts the input points based on itspositions on the Z space-filling curve [2]. For each query point, only a subsetof segments of the Z curve is searched for the existence of anypoint ofΣ thatdominates the query pointp.

A different approach has been proposed in [46] which can workwithboth spherical and retangular queries. Unlike [43] which increases efficiencyby searching only a subset of the set of queries, [46] searches all queriesbut for each visited query the covering condition is quickly, however, tol-erated by a probability of error. To illustrate the idea, suppose that queriesare spherical. Firstly, a constantk < d is pre-determined. Secondly,k ran-dom orthonormal vectors,{u1,u2, ...,uk}, are generated. Then, each querycentered ats with radiusr is mapped to the followingk-dimensional rectan-gle: u(s, r) = u1(s, r)×u2(s, r)× ...×uk(s, r) where each sideui(s, r) of thisrectangle is the projection of the subscription on unit vector ui , which is thefollowing interval: (◦ is the inner product)ui(s, r) = [ui ◦s− r, ui ◦s+ r]. Tocheck whether a querys covers a querys′, we check whether the projectionrectangleu(s) covers the projection rectangleu(s′). If it is found thatu(s)coversu(s′) (or not), it is concluded thats coverss′ (or not). Although thisconclusion is not always correct, it is shown that if queriesare uniformlydistributed in both center points and radii, the probability of error is roughlybounded by(2/π)k. This probability approaches zero quickly ask increases.

The case of rectangular queries is handled similarly. Each original d-dimensional rectangular querys with 2d verticesv1, v2, ..., v2d is mapped toa k-dimensional rectangle where each side is the following interval: ui(s) =[

min j≤2d (v j ◦ui),maxj≤2d (v j ◦ui)]

. Using a similar random projection, witha low probability of error, the subscription covering problem ind dimensionscan be mapped into that ink << d dimensions. The value ofk can be tunedto achieve any given success rate.

36.4 Query Aggregation 13

[38] addresses a more generic covering problem; that is, to find whethera new querys is covered bythe setof existing queriess1∪s2∪ ...∪sn, ratherthan by a single existing query. The basic idea is as follows.First, k points{x1,x2, ...,xk} that satisfysare selected in random. Second, we check whethereach of these points satisfies any of the existing queries. Itis concluded thats is covered if all the selected points satisfy the set of existing queries, andotherwise not covered. Thus, the probability of erronouslyconcluding that aquery is covered is upper-bounded by(1− pw)k, wherepw is the probabilitythat a random pointxi satisfyings also satisfies the set of existing queries.This error probability is quickly improved ask increases.

36.4.2 Subscription Merging/Pruning

Another technique to reduce the number of query replicas in the network isvia subscription merging[36, 25, 50, 17]. Given a set of queriesS, we need tomerge them to create a new set of queriesS′ such that (1)|S|<|S′ | and (2) theevents satisfyingS are the same as that satisfyingS′. Instead of forwardingthe queries inS, we forward the queries inS′, thus reducing the amount ofsubscriptions in the network.

Although subscription merging is theoretically helpful, we cannot alwaysfind a perfect merging for a given set of queries. Even if such amergingexists, its algorithm can be computationally expensive. Indeed, [17] showsthat the merging problem is NP-complete. Consequently, imperfect mergingalgorithms are suggested [36, 50, 17]. These algorithms aimto merge thequeries inS into a new set of queriesS′ such that (1)| S |<| S′ | and (2) theevents satisfyingSare asubsetof that satisfyingS′.

One such an algorithm [50] clustersS into groups of similar queries andthen finds a merging for each group. In another algorithm [36], the representa-tion of a query is based on the concept of ordered Binary Decision Datagram(BDD) [10]. A BDD is a rooted, directed acyclic graph designed for easymanipulations of Boolean functions. A query is expressed asa BDD in whicheach node is a predicate of the query and a solid (dashed) linkfrom a nodemeans that the corresponding predicate is satisfied (unsatisfied). For exam-ple, Figure 36.3(a) shows a BDD for the query{(‘temperature’> 100) AND(‘humidity’ < 50)} OR {(‘temperature’> 100) AND (‘humidity’≥ 50) AND(‘wind speed’> 50) AND (‘wind speed’< 100)}. Given an event, it traversesthe BDD and if terminal node 1 is reached, it is concluded thatthe eventsatisfies the query. To address a large number of queries, thus a large numberof BDDs, a modified version of BDD called MBD is introduced. A MBD


o

(a) A query as a binary decision diagram

o

AND

OR

(b) A query as a boolean tree

Figure 36.3 Examples of query representations

is a forest of BDDs, each representing a query, with the property that if apredicate occurs in multiple queries only one common node isshared amongthese queries to represent the predicate; this predicate isevaluated only once.A MBD thus represents the merging of multiple queries. Winthin a MBD,two predicate nodes can also be merged to create a single nodeto representthe same condition, resulting in a simpler MBD. An event is evaluated on aMBD rather than on each individual query.

Imperfect merging has its tradeoff. At any nodeP where an imperfectmerging ofSinto S′ is performed, we have the problem that many false events,that satisfyS′ but not S, could be returned to nodeP. This is unnecessary

36.5 Event Matching 15

traffic which can be costly for sensor networks. In addition,the computa-tional and space costs to perform subscription merging (perfect or imperfect)may exceed that a sensor node can afford. Thus, subscriptionmerging isrecommended only when its scope is small.

Subscription pruning[7] is another strategy to reduce the query storageload in the network. Each query is represented as a tree [6] inwhich eachinner node represents a Boolean operator (e.g., AND, OR) andeach leafbeing a single-attribute predicate (e.g.,(‘temperature’> 100), or (‘humidity’< 20). For example, Figure 36.3(b) shows the Boolean tree representing thesame query in Figure 36.3(a). The tree is then simplified by pruning off somepredicates or by replacing them with simpler ones. Since thequeries becomesimpler, data structures and algorithms for processing them require less mem-ory and computation. On the other hand, similar to imperfectsubscriptionmerging, subscription pruning also results in notificationof false events.

36.5 Event Matching

When a publication of some event reaches a node where the locally storedqueries need to be evaluated against this event, simply testing every queryand predicate may be computationally expensive for a sensornode, especiallywhen there are numerous, complex queries and high volumes ofevents. Con-sequently, it has been proposed that the queries are organized into some datastructure that enables faster than linear-time event matching.

The Matching Tree in [1] is such a data structure, where the matching timeis sub-linear and the space complexity is linear. This tree allows incrementalquery updates (insert/delete) and is most suitable where events are publishedat a fast rate. Each tree node is a test on some of the attributes and eachlink eminating a node is labeled with a result of the correponding test. Alink with label ‘*’ means a “do not care" link. Each query corresponds to aleaf node and the path from the root to this leaf node consistsof all the testswhose conjunction is equivalent to the query. For example, Figure 36.4 showsa simple matching tree storing three queries:sub1: (attr1 = v1) AND (attr2 =v2) AND (attr3 = v3), sub2: (attr1 = v1) AND (attr3 = v′

3), andsub3: (attr1 =v′1) AND (attr2 = v2) AND (attr3 = v3). To find the queries matching an event,at each node starting at the root, the corresponding test is performed and a linkto the next node is followed if its label matches the result ofthe test. This stepis repeated at the next node. The leaves that are finally visited correspondto the queries that match the event. In the case where a query consists ofequality tests on the attributes, the expected time to matcha random event is


O(n1−λ ) wheren is the number of queries andλ is a parameter dependenton the number and type of attributes (in some cases,λ = 1/2). The constantshidden behind the big-O notation are quite reasonable.

The matching tree structure follows the approach that the search for queriesmatching a given event starts from the attribute constraints derived from thefull set of queries and moves through them consulting the attributes appear-ing in the event. The binary decision datagram (BDD) structure discussedin Section 36.4 also follows this approach. Alternatively,we can start withthe attributes appearing in the event and move through them consulting thequery constraints. An early method adopting this approach is the SIFT system[51], which is the basis for subsequently designed structures [21, 13]. SIFTis limited to strings only and the equality operator over strings. Le Subscribe[21] allows the integer type and its associated operators. [13] adds the prefix,suffix, and substring operators for strings and, especially, allows a query tobe expressed as a disjunction of conjunctive clauses, not just a single con-junctive clause. The matching algorithm in this work is based on a countingalgorithm also used in [21, 51] and when tested on a 950Mhz computer fora 10-attribute event and 20 queries consisting of 25 conjunctions could findthe matching queries in 3 milliseconds. It took 48 bytes of storage for eachelementary predicate. This algorithm is therefore simple and efficient enoughto be implemented on a sensor node.

Another strategy for building an efficient data structure isbased on thequery covering relationship. It is observed that if an eventx matches querys1 (denoted byx ∈ s1) and if we already know thats1 ⊂ s2 for some querys2, then it must be true thatx∈ s2 and we need not check whetherx matchess2. Based on this observation, we should build a data structurethat capturesthe covering relationship among subscriptions. This is similar to the problemof Orthogonal Range Searchin Computational Geometry, for which severalstructures exist such as the kd-tree [5] and the layered range tree [19]. Usingthe kd-tree, the complexities would beO(n1−1/d) for time andO(n) for stor-age, while that using the layered range tree would beO(logdn) for time andO(nlogd−1n) for storage. If one of these two structures must be used, due tothe high storage cost of the layered range tree, the kd-tree should be a betterchoice for sensor networks.

The random projection approach in [48], which was discussedearlier inSection 36.4.1, can be used to expedite the matching procedure. Using a ran-dom projection fromd dimensions tok dimensions (d is the number of eventattributes,k is some small constant), a query is mapped to ak-dimensionalrectangle. To check whether an eventx matches a querys (centeru, radius

36.6 Middleware Development17

!""#$

!""#%

!""#&

!""#%

'()$

!""#& !""#&

'()% '()&

*$

*%

*&

+

*$,

*%

*&*&,

Figure 36.4 Example of a matching tree

r), a quick check can be to verify whether the projectionx′ of x in the k-dimensional space is inside thek-dimensional rectangular projections′ of s.If x′ 6∈ s′, we can immeditately ignores; otherwise, we perform the checkwhetherx∈ sas usual. The first check is performed in ak-dimensional space,thus much quicker than the second check which is in ad-dimensional space.A nice property of this method is that the number of queries that can beignored after the first check increases quickly if a larger value fork is chosen.

36.6 Middleware Development

It is important to have a middleware component that can be integrated ontop of a sensor network to allow for easy deployment of publish/subscribeapplications. An application developer should know just how to call the pub-lish/subscribe functions, not having to worry about the complexity of theunderlying network and the implementation details of the publish/subscribemechanisms. There have been various approaches toward providing mid-dleware services in sensor networks, and according to the categorization in[30], these approaches can be placed in one of the following groups: (1)database-inspired approaches (TinyDB [37], COUGAR [8], SINA [42]); (2)tuple space approaches (TinyLIME [11]); (3) event-based approaches (Mires[44], MQTT-S [33], TinyCOPS [28]; and (4) service discoverybased ap-


proaches (MiLAN [29]). Publish/subscribe middleware belongs to the groupof event-based approaches.

Mires [44] is such a publish/subscribe middleware design, which has beenimplemented using nesC on top of TinyOS 1.x. Mires supportssubject-basedpublish/subscribe applications and provides an architecture that allows sensornodes to advertise the subject of sensor data they can provide, user applica-tions to select subjects of interest from the advertised services, and sensornodes to publish their data to the corresponding subscribers. The subscriptionand notification protocols integrated in this middleware are similar to that ofDirected Fusion. Mires also offers data aggregation services for some com-mon aggregation functions, such as min, max, and average, tohelp reduce theevent traffic in the network.

Another middleware design is the MQTT-S architecture by IBM[33].MQTT-S is an extension of MQTT originally developed for telemetry appli-cations using constrained devices1. This architecture is applicable tosubject-basedpublish/subscribe applications that run in a network integrating multi-ple wireless sensor networks (WSN). Its aim is to hide end-point details: anapplication running on either the backbone network or inside a WSN does notknow whether the data is coming from a device in a WSN or the backbonenetwork. A query can be submitted anywhere in the global network subscrib-ing to events that may belong to one or more participating WSNs. Brokernodes are placed in the backbone network to provide a publish/subscribe ser-vice to the nodes in the backbone network; the broker nodes run the originalMQTT middleware. MQTT-S is used to provide a publish/subscribe servicewithin a single WSN, with two main entities: MQTT-S Client running on asensor node and MQTT-S Gateway running on a gateway node connectingits WSN to the global network. An MQTT-S Client contains botha publisherand a subscriber, thus allowing sensor nodes to not only publish their data,but also receive e.g. control information sent by nodes residing in the globalnetwork. The main function of the gateway is to translate between MQTT-Sand MQTT protocols. This architecture is illustrated in Figure 36.5. MQTT-Sprovides a method to search for a local gateway and allows formultiple gate-ways used per WSN, thus increasing the reliability of the publish/subscribesystem under deployment. MQTT-S has been implemented in a testbed whichcomprises two wireless sensor networks of different types,a ZigBee-basedand a TinyOS-based one. Both implementations are lightweight with about12kB of code. The testbed devices each have only 64kB of program memory

1 http://mqtt.org

36.6 Middleware Development19

Figure 36.5 The MQTT-S middleware architecture

available. The MQTT-S Gateway is written in Java and uses theJava Commu-nications API to communicate with the gateway devices over the serial port.The Gateway connects to a broker using the MQTT protocol. Nodes residingon the TinyOS-based network can communicate with nodes on the ZigBeenetwork via the broker.

Mires and MQTT-S focus on architectural and networking issues andprovide support for simple subject-based subscriptions and publications. Themiddleware development in [52] is aimed for a rich expressiveness of queryand event description. A set of filtering operators is proposed to supportnot only standard comparison and string operators, but alsoallow for spa-tiotemporal constraints. For example, a query can be subscribed to receive theaverage temperature at a specific location during a future period of time. Aproblem with this middleware development is due to the complexity involvedin the implementation of the subscription and notification protocols. Indeed,a complex timestamping scheme is needed to support the temporal operatorsand, further, the spatial operators requires location information which is notalways available for every sensor network [30].

The aforementioned middleware designs tightly integrate filtering, rout-ing and forwarding mechanisms resulting in more optimized,but less flexi-ble solutions. TinyCOPS [28] is aimed to be a unified middleware architec-ture enablingcontent-basedpublish/subscribe applications, not just subject-based, that gives the application developer a wide range of orthogonal choicesabout the communication protocol components to use for subscription andnotification, the supported data attributes, and a set of service extension com-ponents. This allows the adaptation of the publish/subscribe service to thespecific needs of the application to deploy. TinyCOPS also introduces the


concept ofmetadataincluded in the description of each query to influence thecommunication and sensing process. For example, the metadata can specifythe expiration time for a given query or to request a samplingrate eventsshould be sent to the subscriber. TinyCOPS has been implemented to runon top of TinyOS 2.0, in which two communication protocols are integrated(broadcast-based or gossip-based).

36.7 Concluding Remarks

The publish/subscribe paradigm represents a large class ofapplications insensor networks as sensors are designed mainly to detect andnotify uponevents of interests. This important paradigm allows a user to subscribe inadvance a query specifying the early warnings of a wildfire, so that any eventmatching these warnings when detected by a sensor can be published to thenetwork quickly to notify the subscriber. In industrial applications, we canprovide a more secure working environment by deploying a sensor networkthat warns workers upon detection of dangerous events.

Many publish/subscribe techniques for sensor networks have been in-spired by that for traditional Internet-based networks. For example, somegossip-based routing schemes, query aggregation schemes,and event match-ing algorithms that have been designed for the Internet can also be usedin sensor networks, as we discussed earlier in the chapter. There, however,remains much room for future research. For a large-scale sensor networkwhere broadcast-based and gossip-based routing approaches may not be thebest fit, the routing design should be driven by the content ofthe messagebeing routed so as to limit the scope of propagation. In networks wherelocation information is available, it should be a main factor in the routingdesign. In other networks without location information, the naming-basedapproach seems a promising direction, the challenge, however, being howto maintain the naming structure efficiently under network dynamics. Sincesensor networks may be of different types (small vs. large, location-awarevs. location-unaware, static vs. dynamic) and the application to deploy mayalso have its own characteristic (low vs. high query rate, low vs. high eventrate, subject-based vs. content-based, etc.), it is difficult to choose a pub-lish/subscribe design that works well in every case. Thus, rather than tryingto find a universally “perfect" design, it would be better to categorize thenetworks and applications into similarity-based groups and design the “best"technique for each group.

References 21

It is then natural for the next step to be developing a publish/subscribemiddleware package that provides a set of common services tomost pub-lish/subscribe network/applications no matter their categories, and anotherset of services each customized toward a specific category. This middlewareshould provide convenient tools for the middleware designer to add newservice components to the existing architecture, such as a new language forquery and event description and a new implementation for routing, data ag-gregation, or an event matching algorithm. It should also give the applicationdeveloper freedom and a convenient API to choose the publish/subscribe ser-vice configuration that is best for the context of the deployment. Middlewaredevelopment for publish/subscribe applications in sensornetworks remainsad hoc and isolated. It should be a high-priority item in the future researchtowards publish/subscribe services in sensor networks.

References

[1] M. K. Aguilera, R. E. Strom, D. C. Sturman, M. Astley, and T. D. Chandra. Matchingevents in a content-based subscription system. InPODC ’99: Proceedings of the eigh-teenth annual ACM symposium on Principles of distributed computing, pages 53–61.ACM Press, 1999.

[2] T. Asano, D. Ranjan, T. Roos, E. Welzl, and P. Widmayer. Space-filling curves and theiruse in the design of geometric data structures.Theoretical Computer Science, 181(1):3–15, 1997.

[3] C. Avin and B. Krishnamachari. The power of choice in random walks: An empiricalstudy.Comput. Networks, 52(1):44–60, 2008.

[4] M. Avvenuti, A. Vecchio, and G. Turi. A cross-layer approach for publish/subscribe inmobile ad hoc networks. InMATA, volume 3744 ofLecture Notes in Computer Science,pages 203–214. Springer, 2005.

[5] J. L. Bentley. Multidimensional binary search trees used for associative searching.Commun. ACM, 18(9):509–517, 1975.

[6] S. Bittner and A. Hinze. On the benefits of non-canonical filtering in publish/subscribesystems. InICDCSW ’05: Proceedings of the Fourth International Workshop on Dis-tributed Event-Based Systems (DEBS) (ICDCSW’05), pages 451–457, Washington, DC,USA, 2005. IEEE Computer Society.

[7] S. Bittner and A. Hinze. Pruning subscriptions in distributed publish/subscribe systems.In ACSC ’06: Proceedings of the 29th Australasian Computer Science Conference, pages197–206, Darlinghurst, Australia, Australia, 2006. Australian Computer Society, Inc.

[8] P. Bonnet, J. E. Gehrke, and P. Seshadri. Towards sensor database systems. In2ndInternational Conference on Mobile Data Management (MDM), pages 3–14, 2001.

[9] D. Braginsky and D. Estrin. Rumor routing algorthim for sensor networks. InWSNA’02: Proceedings of the 1st ACM international workshop on Wireless sensor networksand applications, pages 22–31. ACM, 2002.


[10] R. E. Bryant. Graph-based algorithms for boolean function manipulation.IEEE Trans.Comput., 35(8):677–691, 1986.

[11] M. G. C. Curino, M. Giorgetta, A. Giusti, A. L. Murphy, and G. P. Picco. Tinylime:Bridging mobile and sensor networks through middleware. In3rd IEEE InternationalConference on Pervasive Computing and Communications (PerCom), pages 61–72,March 2005.

[12] A. Carzaniga, D. S. Rosenblum, and A. L. Wolf. Design andevaluation of a wide-areaevent notification service.ACM Transactions on Computer Systems, 19(3):332–383,2001.

[13] A. Carzaniga and A. L. Wolf. Forwarding in a content-based network. InACMSIGCOMM, pages 163–174, 2003.

[14] R. Chand and P. Felber. Xnet: A reliable content-based publish/subscribe system.In SRDS ’04: Proceedings of the 23rd IEEE International Symposium on ReliableDistributed Systems (SRDS’04), pages 264–273, Washington, DC, USA, 2004. IEEEComputer Society.

[15] P. Costa, C. Mascolo, M. Musolesi, and G. P. Picco. Socially-aware routing for publish-subscribe middleware in delay-tolerant mobile ad hoc networks. IEEE Journal onSelected Areas in Communications, 26(5), 2008.

[16] P. Costa, G. P. Picco, and S. Rossetto. Publish-Subscribe on Sensor Networks: A Semi-probabilistic Approach. InProceedings of the 2nd IEEE International Conference onMobile Ad-hoc and Sensor Systems (MASS05), Washington DC, USA, November 2005.

[17] A. Crespo, O. Buyukkokten, and H. Garcia-Molina. Querymerging: Improving querysubscription processing in a multicast environment.IEEE Transactions on Knowledgeand Data Engineering, 15(1):174–191, 2003.

[18] G. Cugola and H.-A. Jacobsen. Using publish/subscribemiddleware for mobile systems.SIGMOBILE Mob. Comput. Commun. Rev., 6(4):25–33, 2002.

[19] M. de Berg, M. van Kreveld, M. Overmars, and O. Schwarzkopf. Computational geom-etry: algorithms and applications. Springer-Verlag New York, Inc., Secaucus, NJ, USA,1997.

[20] P. T. Eugster, R. G. P. A. Felber, and A.-M. Kernmarrec. The many faces ofpublish/subscribe.ACM Computing Surveys, 35(2):114âAS131, 2003.

[21] F. Fabret, H. A. Jacobsen, F. Llirbat, J. Pereira, K. A. Ross, and D. Shasha. Filteringalgorithms and implementation for very fast publish/subscribe systems. InSIGMOD’01: Proceedings of the 2001 ACM SIGMOD international conference on Managementof data, pages 115–126, New York, NY, USA, 2001. ACM Press.

[22] Q. Fang, J. Gao, and L. J. Guibas. Landmark-based information storage and retrieval insensor networks. InIEEE INFOCOM, 2006.

[23] U. Farooq, E. W. Parsons, and S. Majumdar. Performance of publish/subscribe mid-dleware in mobile wireless networks.SIGSOFT Softw. Eng. Notes, 29(1):278–289,2004.

[24] E. Fidler, H.-A. Jacobsen, G. Li, and S. Mankovski. The padres distributed pub-lish/subscribe system. InFIW, pages 12–30, 2005.

[25] L. Fiege, M. Cilia, G. Muhl, and A. Buchmann. Publish-subscribe grows up: Support formanagement, visibility control, and heterogeneity.IEEE Internet Computing, 10(1):48–55, 2006.

References 23

[26] D. Frey and G.-C. Roman. Context-aware publish subscribe in mobile ad hoc networks.In International Conference on Coordination Models and Languages (COORDINATION2007), pages 37–55, 2007.

[27] S. Funke, L. J. Guibas, A. Nguyen, and Y. Wang. Distance-sensitive informationbrokerage in sensor networks. InDCOSS, pages 234–251, 2006.

[28] J.-H. Hauer, V. Handziski, A. Kaopke, A. Willig, and A. Wolisz. A component frame-work for content-based publish/subscribe in sensor networks. InEuropean Workshop onWireless Sensor Networks (EWSN), Bologna, Italy, January 2008.

[29] W. B. Heinzelman, A. L. Murphy, H. S. Carvalho, and M. A. Perillo. Middleware tosupport sensor network applications.IEEE Network, 18(1):6–14, August 2004.

[30] K. Henricksen and R. Robinson. A survey of middleware for sensor networks: State ofthe art and future directions. InACM Workshop on Middleware for Sensor Networks,Melbourne, Australia, 2006.

[31] Y. Huang and H. Garcia-Molina. Publish/subscribe treeconstruction in wireless ad-hocnetworks. InMDM ’03: Proceedings of the 4th International Conference onMobileData Management, pages 122–140, London, UK, 2003. Springer-Verlag.

[32] Y. Huang and H. Garcia-Molina. Publish/subscribe in a mobile environment. Wirel.Netw., 10(6):643–652, 2004.

[33] U. Hunkeler, H.-L. Truong, and A. Stanford-Clark. MQTT-S: A publish/subscribe proto-col for wireless sensor networks. InWorkshop on Information Assurance for MiddlewareCommunications (IAMCOM ‘08), Bangalore, India, January 2008.

[34] C. Intanagonwiwat, R. Govindan, and D. Estrin. Directed diffusion: a scalable and robustcommunication paradigm for sensor networks. InMobiCom ’00: Proceedings of the 6thannual international conference on Mobile computing and networking, pages 56–67.ACM Press, 2000.

[35] B. Karp and H. T. Kung. Gpsr: greedy perimeter statelessrouting for wireless networks.In MobiCom ’00: Proceedings of the 6th annual international conference on Mobilecomputing and networking, pages 243–254, New York, NY, USA, 2000. ACM Press.

[36] G. Li, S. Hou, and H.-A. Jacobsen. A unified approach to routing, covering and mergingin publish/subscribe systems based on modified binary decision diagrams. InICDCS’05: Proceedings of the 25th IEEE International Conferenceon Distributed ComputingSystems (ICDCS’05), pages 447–457, Washington, DC, USA, 2005. IEEE ComputerSociety.

[37] S. Madden, M. J. Franklin, J. M. Hellerstein, and W. Hong. TinyDB: An acquisitionalquery processing system for sensor networks.ACM Transactions on Database Systems,30(1):122–173, 2005.

[38] A. M. Ouksel, O. Jurca, I. Podnar, and K. Aberer. Efficient probabilistic subsump-tion checking for content-based publish/subscribe systems. In ACM/IFIP/USENIX 7thInternational Middleware Conference, pages 121–140, 2006.

[39] S. Ratnasamy, B. Karp, S. Shenker, D. Estrin, R. Govindan, L. Yin, and F. Yu. Data-centric storage in sensornets with ght, a geographic hash table. Mob. Netw. Appl.,8(4):427–442, 2003.

[40] R. Sarkar, X. Zhu, and J. Gao. Double rulings for information brokerage in sensornetworks. InMobiCom ’06: Proceedings of the 12th annual international conference onMobile computing and networking, pages 286–297, New York, NY, USA, 2006. ACM.

[41] J. H. Schönherr, H. Parzyjegla, and G. Mühl. Clustered publish/subscribe in wirelessactuator and sensor networks. InMPAC ’08: Proceedings of the 6th international work-shop on Middleware for pervasive and ad-hoc computing, pages 60–65, New York, NY,USA, 2008. ACM.

[42] C.-C. Shen, C. Srisathapornphat, and C. Jaikaeo. Sensor information networking ar-chitecture and applications.IEEE Personal Communications, 8(4):52âAS–59, August2001.

[43] Z. Shen and S. Tirthapura. Approximate covering detection among content-based sub-scriptions using space filling curves. InIEEE International Conference on DistributedComputing Systems, Toronto, Canada, June 2007.

[44] E. Souto, G. Guimaraes, G. Vasconcelos, M. Vieira, N. Rosa, C. Ferraz, and J. Kel-ner. Mires: a publish/subscribe middleware for sensor networks. Personal UbiquitousComput., 10(1):37–44, 2005.

[45] W. W. Terpstra, J. Kangasharju, C. Leng, and A. P. Buchmann. Bubblestorm: resilient,probabilistic, and exhaustive peer-to-peer search. InSIGCOMM ’07: Proceedings ofthe 2007 conference on Applications, technologies, architectures, and protocols forcomputer communications, pages 49–60, New York, NY, USA, 2007. ACM.

[46] D. A. Tran and T. Nguyen. Subscription covering detection in publish/subscribe systemsbased on random projections. InProceedings of IEEE Int’l Conference on CollaborativeComputing (COLLABORATECOM 2007), White Plains, NY, October 2007. IEEE Press.

[47] D. A. Tran and T. Nguyen. Localization in wireless sensor networks based on supportvector machines.IEEE Transactions on Parallel and Distributed Systems, 19(7):981–994, July 2008.

[48] D. A. Tran and C. Pham. Cost-effective multidimensional publish/subscribe services insensor networks. InIEEE Workshop on Localized Communications Algorithms and Net-works - IEEE Conference on Mobile Ad hoc and Sensor Systems (MASS 2008), Atlanta,GA, September 2008. IEEE Press.

[49] D. A. Tran and C. Pham. A content-guided publish/subscribe mechanism for sen-sor networks without location information.Journal on Computer Communications(COMCOM), 33(13):1515–1523, August 2010.

[50] Y.-M. Wang, L. Qiu, C. Verbowski, D. Achlioptas, G. Das,and P. Larson. Summary-based routing for content-based event distribution networks. SIGCOMM Comput.Commun. Rev., 34(5):59–74, 2004.

[51] T. W. Yan and H. Garcia-Molina. The sift information dissemination system.ACMTrans. Database Syst., 24(4):529–565, 1999.

[52] E. Yoneki and J. Bacon. Unified semantics for event correlation over time and spacein hybrid network environments. InIFIP International Conference on CooperativeInformation Systems (CoopIS), pages 366–384, 2005.

[53] Q. Yuan and J. Wu. Drip: A dynamic voronoi regions-basedpublish/subscribe pro-tocol in mobile networks. InINFOCOM 2008. The 27th Conference on ComputerCommunications. IEEE, pages 2110–2118, 2008.

Prasad, Buford, and Gurbani (Eds.), Advances in Next Generation Services andService Architectures,1–24.c© 2010River Publishers. All rights reserved.

Documents

Enabling Publish/Subscribe Services in Sensor Networks