Fuzzy Logic-Based Event Notification in Sparse MANETs - CiteSeerX

Fuzzy Logic-Based Event Notification in Sparse MANETs Anna Lekova, Katrine Skjelsvik1, Thomas Plagemann1, Vera Goebel1 Institute of Control and System Research, Bulgarian Academy of Sciences 1 Department of Informatics, University of Oslo, Norway [email protected], 1{katrins, goebel, plageman}@ifi.uio.no Abstract In the Ad-Hoc InfoWare project, we develop a delay tolerant event notification service for sparse Mobile Ad-Hoc Networks for emergency and rescue operations. In most event notification solutions, subscriptions are formed with crisp values or crisp value ranges. Filtering mechanisms do not take into account more expressive subscriptions in terms of approximate predicates and complex aggregating relations among them. However, in emergency scenarios subscribers’ interests often have gradual nature and subjective measure. Therefore, we design an intelligent event notification system allowing uncertainties to be modeled and complex matching semantics to be processed by fuzzy reasoning. Requiring more computational efforts, fuzzy logic introduces performance penalties in the whole network. We have developed a new subscription data structure and filtering algorithms, and evaluated and optimized it for runtime and space efficiency.

1. Introduction In the Ad-Hoc InfoWare project [2], we are developing middleware services for emergency and rescue applications for sparse Mobile Ad-Hoc Networks (MANETs). These networks have low node density and high node mobility, and the middleware services must therefore handle network partitions and provide a delay tolerant Distributed Event Notification Service (DENS) to the applications [6]. An event is a change in data of interest. The node that identifies this change is called a publisher. A subscriber describes in a subscription “when” and “what” it wants to be notified about by means of selection predicates. A notification message describes an event. In [6], a set of so-called DENS nodes forms an overlay responsible for delivering subscriptions and notifications, to replicate them, and to perform store-carry-forward operations. In addition to the dissemination process, the other main design decision for the DENS is the subscription specification and event filtering, i.e., the subscription language, that determines the usefulness of the DENS for different applications. If a simple

language is sufficient it should be used to save resources. However, there might be applications that benefit from more complex subscription filters, e.g. to capture uncertain data during rescue operations. For instance, agents in the RoboCup rescue scenario gather and circulate information for observed fires, smoke or even “the danger” in the vicinity. Transitional values as “semi-burning” would be helpful and need to be modeled by qualitative terms in predicates. Agent online decisions might be aided by an intelligent approach for computing with words by exploiting fuzzy logic, introduced by Zadeh [7]. Fuzzy logic captures human experience and supports contradictory and “gray” statements. Related works (such as [3], [4], [5], [8], [9], [11]) dealing with fuzzy reasoning have been done in wireless sensor networks for event detection and context-awareness, in MANETs for content-aware computing, clustering and routing, as well as in data engineering for fuzzy querying. Requiring more computational efforts and space, fuzzy logic might introduce performance penalties in the whole network when not carefully designed. There are three important issues: (1) the representation of fuzzy subscriptions might consume too much space on nodes, and bandwith; (2) if source filtering is used, the fuzzy filtering might be too complex for these nodes; (3) to forward notifications to subscribers, the DENS has to match subscriptions and notifications. The efficiency and scalability of this forwarding process in the DENS overlay depends on the complexity of the matching. The contribution of this paper is to describe the design, implementation and evaluation of fuzzy-logic based event notification, that allow uncertainties to be modeled and complex matching semantics to be processed by fuzzy reasoning. The remainder of this paper is structured as follows: In Section 2, we briefly describe the need for fuzzy-concept based services, DENS requirements and our solutions. In Section 3, fuzzy modeling and processing of uncertainties are proposed. In Section 4, the implementation, emulation and evaluation of the proposed fuzzy-based data model and algorithms in Sun Java Wireless Toolkit and NEMAN are presented.

2. The Need of Fuzzy-Based Services A survey and classification of subscription languages is made in [1]. In most event notification solutions, subscriptions are formed with crisp values or crisp value ranges as constraints in predicates. However, in emergency and rescue operations, subscriber's interests often have gradual and subjective measure or there may not always be time to give crisp values or ranges in queries. Lack of transitional boundaries does not take into account if values are slightly outside of the interval. Almost all filtering algorithms support only conjunctions of predicates in subscriptions. The matching consists of comparing the number of fulfilled predicates and the number of predicates in the subscription, and do not use any complex event matching. However, a subscriber might be more or less sensitive to some attributes. Given that, aggregating relations could be minimum, product, weighted or balance average. Complex filters might be unknown or highly non-linear application-defined functions, as well. For instance, if three indicators are observed, two alarms for them are of bigger importance than three alarm indications that are not so critical. Such nonlinear aggregation is similar to “geometric mean average”, which uses a square root - an expensive operation in terms of processing time. Hence, it is of interest to obtain techniques for function approximation. Based on these, we embed intelligence into event notification services by fuzzy reasoning that can deal with uncertainties and approximations that exist when subscribers want to obtain information.

2.1 Review of Fuzzy Logic Theory Fuzzy logic is a superset of classical logic with the introduction of “degree of membership”. Uncertainties are presented as fuzzy sets (Ai), which are often expressed by words and interpreted by their membership functions µA. A fuzzifier is used at the input of the system to convert crisp to fuzzy data, while a defuzzifier - from fuzzy to crisp data. The fuzzifier converts each element of crisp data x from a certain domain (D) into fuzzy set using the concept of degree of membership of x to A - µA(x), which is a number in [0÷1]. Fuzzified input data trigger one or several rules in the fuzzy model to calculate the result. IF-THEN rules map the input values to the output space in terms of implication relation between fuzzy sets in “IF” and “THEN” parts. Fuzzy reasoning is numerically processing of the information in the fuzzy rules. If A1 and A2 are two fuzzy sets, their Fuzzy Cartesian Product (FCP) is a set consisting of all pairs (x1, x2) where x1 ∈ A1 and x2 ∈ A2 [8]. x1 ∈ A1; x2 ∈A2},

R A1×A2 = { µ A1×A2(x1, x2)/( x1, x2){ where µ A1×A2 (x1, x2) = T-(co)norm(µ A1(x1), µ A2(x2)) µ A1×A2 defines “two-dimensional fuzzy set” over the FCP.

Usually FCP is interpreted geometrically in all 2Dprojections in the Euclidean space. We exploit the Takagi-Sugeno fuzzy model (TS) as a universal function approximator [10]. Its structure consists of rules in the following form: n

R i : IF x

is A i THEN

y i = a 0i +

∑a

(1)

i k xk

k =1

where x = ( x1 , x2 ,..., xn ) ∈ D is a vector representing the inputs defined on D. Ai is a fuzzy set defined on D; yi is a scalar output corresponding to rule i ; aki are the consequence parameters associated to rule i. i ∈ { 1,..., p } , where p is the number of rules. The rules are aggregated and defuzzified by using the fuzzy-mean formula: p

p

y( x ) =

∑

μ Aik ( x ) ∗ y i

i =1

∑μ

(2)

Ai ( x )

i =1

where μ Aik ( x ) is the degree of fulfillment of i-th rule. n'

μ Ai ( x ) = μ Aik ( x1 , x 2 ,..., x n ) =

Tμ

Aik ( x k )

, where

n'

is the num-

k =1

ber of input variables in i-th rule ( n' (co)norm as minimum, product, etc.

≤ n ),

T is a type of t-

2.2 Requirements from DENS The fact that event filtering and routing are decoupled in DENS, enables us to develop a new fuzzy subscription language for DENS without changing the existing distribution protocols for the DENS overlay. Fig. 1 shows the DENS architecture, which is described in detail in [4]. We use source filtering to save bandwidth. When DENS receives a notification, it matches the notification with the stored subscriptions and delivers it to the correct subscribers. The available subscriptions on publisher nodes and DENS nodes are summarized in form of a Fuzzy Rule Base (FRB). To address DENS concerns on space and computational efficiency, it is crucial to design efficient publish/subscribe algorithms and data structures. Subscriptions and notifications are replicated in the DENS overlay to increase availability, and therefore need to be compressed. DENS Overlay SubProtocol Sub/DENS DENS

DENS6

Install Install

N/S N/S Fuzzy Matching Matching WD

PubProtocol Pub/DENS DENS

DENS Protocol DENS/DENS DENS

Storage mgmt

Availability Availability & Scaling Scaling

DENS2 DENS2

DENS4

Watchdog

Watchdog W atchdog Manager Manager

App

Sub/DENS Event Fuzzy Event Filtering Filtering

WD/App Publisher Node5

W atchdog Execution Environment

Subscriber Node3

Sub/DENS Subscriber Node1

Figure 1. DENS Architecture The filtering and matching of numerical values in events and notifications to imprecise data in subscriptions are called fuzzy filtering/matching. A fuzzy data-driven model

is used to perform reasoning in order dictated by active subscription filters. It is evident that a priori the fuzzy rule base for event notification could not be placed on the nodes, since the identification of inputs, fuzzy terms and fuzzy membership functions depend on the constraints in the active subscriptions. Hence, an intelligent Fuzzy Inference System (FIS) configuring and adapting its performance to the data in subscriptions has to be designed. However, most of conventional fuzzy toolboxes fall short of such a design framework that allows customization and self-configuration of the number of inputs and outputs, as well as the set of fuzzy rules at runtime. A few existing content-based publish/subscribe systems can model uncertainties for the information in subscriptions and notifications, and can perform uncertain event filtering [4,5,8], however they do not fulfill all our DENS requirements. Most relevant to our work is ECHOES [8]. It proposes uncertain event-based services enhanced with complex filters by using temporal and fuzzy logic formulas. However, ECHOES requires expensive string-based parsing to analyze and evaluate formulas in the network. In our approach, subscribers are involved in the process of saving resources by specifying subscriptions using a decomposition approximation technique to create complex filters. This relieves them also from learning a completely novel language. The design of A-ToPSS [5] is not targeted for mobile environments and does not support different aggregators at runtime. Its model is based on possibility and fuzzy set theory to process uncertainties in either subscriptions or notifications. The filtering algorithm exploits a onedimensional index structure and processes it in two stages. First, predicates are matched, and second, matching subscriptions are identified, which is a cost solution for scarce resources in terms of space efficiency and loading time. A fuzzy tuple space implementation extends LighTS [4].The matching semantic combines the membership grades using a fuzzy aggregating operator from a FuzzyTuple library. It does not support complex aggregating relations.

2.3 Our Design Solutions We propose the following design solutions to reduce the space and computational performance penalties that fuzzybased event notification imposes: (1) a data-driven fuzzy model; (2) assigning features to subscription and notifications for efficient binary encoding, disseminating and processing of fuzzy sets in subscriptions; (3) the Decomposition Approximation (DA) into FCP space; and (4) some algorithm optimizations. The data-driven fuzzy model is configurable to publish/subscribe needs at runtime by exploiting fuzzy rules with variable fuzzy regions. These regions are customized on the subscriber node by mapping the membership functions of the input fuzzy terms in the subscription to the parameters of a fuzzifier used in the data-driven fuzzy model. Thus, space efficiency in DENS is improved, since

the subscriptions do not carry the whole mathematical description of input fuzzy membership functions along their lifetime. The subscription model and filtering algorithms are built on a new idea to assign features for efficient binary encoding of subscriptions and notifications. Features, are arrays of bits indicating the state of the subscription attributes. The value “1” indicates that there is a constraint value about this attribute, e.g., if the subscription is only interested in attribute 4, 5 and 6, the corresponding bits are set to “1” and all others to “0”, thus, the feature array value is 56. Features are used for configuring and adapting the parameters in fuzzy rules. The fuzzy-based filtering/matching algorithm is based on two stages: first, we apply the membership functions of the constraints in the subscription predicates to the actual values in the notification to evaluate the partial degrees of similarities to predicates. Then, one or more rules are triggered from the FRB (tailored according to the active aggregating relation) to compute the overall score for relevance of subscriptions to this notification. Our implementation and measurements show that approximation of non-linear aggregating relations saves scarce mobile resources. Although relation function may contain complex computations, it might be well linearly approximated in small 2D areas. Such a function (Eq. 4) is approximated in Fig. 4. and presents significant improvement on matching time, since approximation avoids method invocations or execution of mathematical library operations. We propose a new decomposition approximation for complex aggregating relations. The scheme relies on domain decomposition of subscription constraints into FCP space, where local TS fuzzy models are applied. In the first stage, all two-dimensional grades are computed and semantically grouped to identify the premise parameters of the TS model. The linear approximation of the aggregating function for each fuzzy relation specifies the consequence parameters. Partial results are aggregated and defuzzified by the fuzzy-mean formula. We suggest different optimizations of filtering and matching algorithms. Subscriptions are indexed, sorted and grouped according to their features and covering relations. If active subscriptions are aggregated by covering, many subscriptions can be evaluated using a single matching. Subscription SA1 covers SA2 if all events which are valid for SA2 are also valid for SA1 [1]. Covering of subscriptions is exploited for reducing the sent notifications: if two notifications NA1 and NA2 match SA1 and SA2, SA1 covers SA2, then NA1 covers NA2.

3. Modeling and Processing of Uncertainties A fuzzy-based subscription s contains a set of fuzzy predicates combined by Boolean- or user-defined operators that describe how the predicates in s can be aggregated. A fuzzy predicate is an “attribute-operator- µA” triple:

s(x1 , · · · , xm ) = AR( { x1 op μ A1( x1 )},...,{ xm op μ Am ( xm )}) ,

where x is the attribute name, ’op’ is the operator and could be: is, is not, “more or less”, etc., and AR is an aggregating relation. For a given input vector (x1,...,xm) in D, AR yields the truth value for relevance (overall score) of s to this input.

3.1. Modeling of Uncertainties XML schema enables subscribers to easily write queries over events. However, since XML documents require costly parsing on DENS, subscriptions are encoded in binary format on the subscriber node. Tags for representing consist of information about fuzzy variables, domains, constraints as fuzzy sets and fuzzifiers. The values of constraints are normalized in the range [0÷1] according to their domains and are disseminated as a sequence of three fuzzy parameters (vi;Vi,γ), where vi and Vi are the right and left borders of the area where the membership grade is 1 (Fig. 2). Vi is equal to vi in case of triangular µA. We have chosen trapezoid and triangular fuzzifiers (Eq. 3) since the computational cost of these membership functions is linear. Notation γ is a sensitive parameter describing the generalization region of the corresponding fuzzy set. γ determines the spreads of µA as a tangent of ∠CAF . The larger γ the less fuzziness. When a subscription consists of string or crisp predicates, vi=Vi. γ is large enough to eliminate the spreads of the fuzzy set. C

μ1 A

vi – 1/γi

µi

F

vi

Vi

x

Figure 2. One-Dimensional memb. Function m Ai ( xi ) = 1 if vi < xi < Vi ;or [ 1 − max( 0 , min( 1,γ ( vi − xi )))] if xi < vi ; (3)

A subscription is a vector (SV) with variable-length of bytes depending on number of predicates. First 7 bytes in the SV store features (SF), ID number, timestamp, etc. The data structure of a subscription is presented in Fig. 3. Each bit in SF indexes the offset in SV: the position where a membership function parameters describes the user’s constraint about this attribute. SF 0 0 1 1 1 0 0 0 Byte offset γ3 γ2 γ1 v3 V3 v2 V2 v1 V1 I D i n f o SV NF 0 0 1 1 1 0 0 0 x3 x2 x1

n

Λ overall

I D i n f o NV

Figure 3. Subscription Structure

3.2. Processing of Uncertainties The degree of relevance of the subscription to the input notification is yielded by fuzzy reasoning how to aggregate all membership grades of predicates in s. In Section 4, we

( X )=

∑

i =1

μ i2

n

∑1

(4)

i =1

where µi is a partial similarity for notification i-th value to i-th predicate. Decomposition approximation in each fuzzy 2D projection has been employed by using TS model and “product” t-norm in “IF” parts of rules. The number of projections is: proj =

Vi + 1/γi

or [ 1 − max( 0 , min( 1,γ ( xi − Vi )))] if xi > Vi

compare three types of filtering/matching algorithms: one using predicate indexing, one without indexing and one with decomposition of the input variables into FCP. A flat non-indexing algorithm with features (FNIF) proposes optimizations using features. First, the features of subscription and notification vectors are matched via bitwise operators. Second, if positive match in the first step, fuzzy reasoning is applied. If features of active subscriptions on the node are sorted (FNIFS), the algorithm stops earlier rather than to evaluate all subscriptions in a first step. A flat nonindexing algorithm with features that are assigned after covering the subscriptions is FNIFC. A flat matching algorithm with predicate indexing is FIP. Two breakdown filtering algorithms decomposing the input filters into FCP space have been designed: decomposition approximation using of first-order TS model (BFCPA1) and zero-order TS model (BFCPA2). We give a numerical example how the new proposed DA schema could be applied using BFCPA1 and application-defined aggregation (AR) concerning the importance of two or more attribute values more close to alarms than all values moderate close to alarms, described by (Eq. 4).

n * (n - 1) , 2

(5)

where n is the number of predicates in s. The idea is to partition the input space in FCP such that a linear approximation of complex or unknown aggregating relation is possible in that range with accepted users’ error range less than 5%. The goal of DA is to obtain the premise and consequence parameters of TS fuzzy model when input partial degrees of similarities to predicates, output local linear models of aggregating relation and required model error ε are given. The less the rules (i.e., coarse fuzzy partition) the bigger is the error. The first step in the DA schema is: in all 2D projections to identify the group of states having similar linear approximation of AR, and to distinguish these states as fuzzy sets. Their membership functions will classify the partial similarities into these fuzzy sets. The next step is to find the local approximation linear solutions to each one of the states and to aggregate and defuzzify them by Eq. 2. Fig.4 shows how Λ is approximated linearly in first projection for three semantically closed groups: “rather large”, “large” and “very large”. We just show trend lines and their equations and squired errors. If the error is not acceptable, the first step is repeated. Else, the premise parameters of fuzzifiers are derived. They are presented in Fig. 5. and in the first column of Table 1.

0,900

m2 [0,1]

4. Implementation and Evaluation

Linear Approximation of Λ max y = 0,4564x + 0,5421 R2 = 0,9991

1,000

(m1=1)

y = 0,5131x + 0,391

0,800

R2 = 0,9994

(m1=0.8) 0,700

(m1=0.6)

y = 0,5759x + 0,2477 R2 = 0,9997

0,600

0,6

Λ [0,1]

0,7

0,8

0,9

1

Figure 4. Consequence Parameters Having premise and consequence parameters we can write the FRB for linearly approximation of Eq. 4: FRB R1 : If μ1 is very_large1 and μ 2 is large2 then y = 0.4564μ 2 + 0.542 R2 : If μ1 is large1 and μ 2 is large2 then y = 0.513μ 2 + 0.391 R3 : If μ1 is rather_large1 and μ 2 is large2 then y = 0.5759μ 2 + 0.2477 m1 rather

Large

Very large

L

VL

large RL

0.6

0.8

1

µ1

m2 Large (L)

0.7

1 µ2

Figure 5. Premise Parameters Table 1 Fuzzy Resoning µ1/ µ2

L (vL=0.7;VL=1, γ=10)

VL (vVL=VVL=1, γ=5)

ΛR1 proj = 0.4564μ 2 + 0.542

L (vL=VL=0.8, γ=5) RL (vRL=VRL=0.6, γ=5)

ΛR2 proj = 0.513μ 2 + 0.391 ΛR3 proj = 0.5759μ 2 + 0.2477

Let us take a 3-attribute notification, which predicate partial similarities are (0.75, 0.82, 0.65). Using Eq.3 we obtain the degree of memberships according to the membership functions presented in Fig. 5. m RathL arg ei ( 0.75 ) = [ 1 − max( 0 , min( 1,5 * ( 0.75 − 0.6 )))] = 0.25 m L arg ei ( 0.75 ) = [ 1 − max( 0 , min( 1,5 * ( 0.8 − 0.75 )))] = 0.75

mVeryL arg ei ( 0.75 ) = [ 1 − max( 0, min(1,5* ( 1 − 0.75 )))] = 0 mRathL arg ei ( 0.82 ) = [ 1 − max( 0, min(1,5* ( 0.82 − 0.6 )))] = 0 and so forth

If AR is Eq. 4, the overall score is 0.743. Using DA, i.e., the fuzzy reasoning given in Table 1, we obtain the degrees of relevance in all projections. By Eq. 2 we get the crisp value of overall score of s to this input -

~

Λ = 0.751.

~

Λ Proj1(0.75, 0.82) = 0 * 1 * (0.456 * 0.82 + 0.542) + +

0.75 * 1 * (0.513 * 0.82 + 0.391) + 0.25 * 1 * (0.5759 * 0.82 + 0.2477)

~

~

Λ Proj 2(0.75, 0.65) = 0 * 0.5 * (0.456 * 0.65 + 0.542) +

Λ= +

0.75 * 0.5 * (0.513 * 0.65 + 0.391) + 0.25 * 0.5 * (0.5759 * 0.65 + 0.2477)

~

Λ Proj3(0.82, 0.65) = 0.1 * 0.5 * (0.456 * 0.65 + 0.542) + 0.9 * 0.5 * (0.513 * 0.65 + 0.391) + 0 * 0.5 * (0.5759 * 0.65 + 0.2477)

(0 + 0.75 + 0.25 + 0+ 0.375 + 0.125 + 0.05 + 0.45 + 0)

In this section we present the implementation, emulation and evaluation of the proposed fuzzy-concept based data model and algorithms in Sun Java Wireless Toolkit 2.3 (WTK23) and NEMAN. Our first experiment was to implement and compare the matching times for the crisp and fuzzy algorithms on DENS overlay in NEMAN [10], a network emulator for MANETs with the following parameters: 50 nodes; time 500 units; transmission 250 units; random waypoint mobility model; OLSR routing protocol and area size 2500x2500 units. We have used a wireless weather station “WS 2305” sending values to publisher nodes. To put up a test scenario we had up to 1000 randomly generated subscriptions. The publisher starts publishing notifications over a 1 second period for 200 measured events. We varied the workload up to 1000 subscriptions with 3 and 4 attributes. The time to do the matching was ~100 ms for the fuzzy flat algorithm, ~600 ms for the “breakdown” one and negligible for the attribute-valued crisp algorithm. These results showed that fuzzy event notification could be supported and is relatively comparable to crisp one. We evaluated the behavior on the publisher and DENS nodes according to the application workload, the subscription specification and the degree of expressiveness of subscriptions. More expressive subscriptions, using approximate predicates and complex aggregating relations among them, influenced the scalability of the implementation on mobile devices. We can process up to 10000 subscriptions for about 2500 ms. Fig. 6.a. shows the time for filtering of 200 events when the number of inserted subscriptions on the publisher varied every one second. FNIF increases linearly with the number of subscriptions. If subscriptions’ covering is performed (FNIFC), the filtering time is flat and low since subscription equality in the system is increasing up to 96% for 1000 subscriptions. For the sake of simplicity, next figures show the filtering times of one event according to different number of subscriptions. Different times have been observed when product, SQRT and arithmetic mean-aggregating relations have been used (Fig. 6.b.). Java Math square root is the most costly operator. Approximated SQRT aggregator achieves an improvement on runtime. Best performance on the DENS node shows algorithm exploiting sorted features and covering - 6.5-7 ms (Fig. 6.c.). However, optimized algorithms require extra subscription loading time. If predicates of subscriptions are hashed and indexed (FIP), the matching time is low 6-6.5 ms, however the loading time is large (Fig. 6.d.). The memory footprint of FIS implementation on DENS is 22KB. Allocated resident memory for 1000 subscriptions and different filtering/matching algorithms is in the range of [150÷300] KB.

the expressiveness of a subscription language and losing the portability. After measuring the cost of fuzzy-based solutions for modeling and disseminating of subscriptions with uncertainties, we established that fuzzy event notification was well supported and the load was tolerable for limited mobile devices.

Filte ring of #200 events Filtering Tim e [m s]

50000 40000 FNIF

30000

FNIFC

20000 10000 0 0

200

400

600

800

1000 #sub

6. Acknowledgments

a) Filtering time for 200 events

M atching Tim e[m s

This research has been performed in the Ad-Hoc InfoWare project No. 152929/431, funded by the IKT2010 Program of the Norwegian Research Council.

Aggregating Relations (AR)

500

400

300

200

7. References

100

0

#sub 0

200

400

Product Aggregator J2ME Math SQRT BFCPA1

600

800

1000

Appr SQRT Aggregator Aritmetic Mean Aggregator BFCPA2

b) Matching time for different aggregating relations Algorithms for Matching on DENS node

20

MatchingTime[ms]

FNIF 15 FNIFC 10 FNIFS

[1]

A. Carzaniga, D. Rosenblum and A. Wolf., “Achieving Scalability and Expressiveness in an Internet-Scale Event Notification Service”, ACM Symp. on Principles of Distributed Computing (PODC), 2000, pp. 219-227. [2] E. Munthe-Kaas, O. Drugan, V. Goebel, T. Plagemann, M. Puzar, N. Sandersson, K. Skjelsvik, “Mobile Middleware for Rescue and Emergency Scenarios” (book chapter) in Mobile Middleware, P. Bellavista, A. Corradi, (Eds.), CRC Press, ISBN 0-8493-3833-6, September, 2006. [3]

5

FNIFC+F NIFS

0

0

200

400

#sub 600

FIP

800

1000

[4]

c) Matching time on DENS node [5] Algorithms for Matching on DENS node

LoadingTime [ms]

500

FNIF

400 FNIFC

[6]

300 FNIFS

200

FNIFC+ FNIFS

100 0

0

200

400#sub600

FIP

800

[7] [8]

1000

d) Loading time on DENS node Figure 6. Emulations in Sun Java Wireless Toolkit [9] Since, we evaluate subscriptions with crisp and approximate predicates, in addition to complex aggregating functions, the presented measurements could be partially compared to the java-based implementation of the prototype presented in [2] that uses fuzzy tuples. For 1000 tuples the matching time is 1.81-4.16 s. If we approximately represent these tuples in our prototype as 350 subscriptions consisting about 1000 predicates, our test shows times of 30-45 ms.

5. Conclusions The paper presented a design of subscription data structures and algorithms that can be used to perform fuzzybased event notification services in DENS. These services could be performed on mobile device without restricting

[10] [11] [12] [13]

E. Yoneki "ECCO: Data centric asynchronous communication", Technical Report 677, 2006. G. Picco, D. Balzarotti and P. Costa, “Lights: A Lightweight, Customizable Tuple Space Supporting Context-Aware Applications”, ACM Symp. on Applied Computing, 2005, pp.413-419 H. Liu, A. Jacobsen, Modelling “Uncertainties in Publish/Subscribe”, Int. IEEE Conf. on Data Engineering (ICDE), Boston, MA, June 2004, pp. 510-522. K. Skjelsvik, V. Goebel, T. Plagemann, ”Distributed Event Notification Service for Mobile Ad Hoc Networks”, IEEE Distributed Systems Online, Vol. 5, No. 8, 2004. L. Zadeh, “Fuzzy logic = computing with words”, IEEE Trans. On Fuzzy Systems, Vol. 4, No. 2, 1996, pp.104–111. M. Caporuscio and P. Inverardi, “Uncertain Event-Based Model for Egocentric Context Sensing”, SEM’05, Sept, Lisbon, Portugal, 2005, pp. 25-32 M. Halgamuge, S. Guru, A. Jennings, Energy efficient cluster formation in wireless sensor networks, 10th ICT 2003, Vol.2, Iss., 23 Feb.-March 2003, pp. 1571- 1576 M. Pužar, T. Plagemann, “NEMAN: A Network Emulator for Mobile Ad-Hoc Networks”, 8th ConTEL, Zagreb, June 2005. Q. Liang, L. Wang, “Event detection in wireless sensor networks using fuzzy logic system”, IEEE Conf. CIHSPS 2005, Vol., Iss., 31, April 2005, pp 52- 55. R. Yager, D.P.Filev, “Essential of Fuzzy Modeling and Contro”, Wiley, New York, 1994. T. Takagi and M. Sugeno, “Fuzzy Identification Of Systems And Its Applications To Modeling And Control”, IEEE Trans. Syst., Man and Cybernetic, Vol. 15, 1985, pp.116–132.