N-tier Quorum System for Bloom based XML Data Replication in Mobile Peer-to-Peer Networks Ratul Mukhopadhyay Wipro Technologies Bangalore, India [email protected]

Abstract Mobile ad-hoc networks consist of highly dynamic nodes. This dynamism often manifests itself in the form of network partitions. A mobile peer-to-peer network is basically a class of applications that have been built on top of an ad-hoc network. This kind of a setup requires alternate means of data dissemination. XML is now being widely adopted as the standard for semi-structured hierarchical data. In this paper, we have used Breadth and Depth Bloom filters to index XML data over mobile peerto-peer networks. This results in increased scalability of XML files. Furthermore, we also extend the classic concept of quorum system to what we call N-tier quorum system, in order to provide data replication, thereby increasing the availability of XML data.

1.Introduction Mobile ad-hoc networks [14][15] are a class of networks that consist of highly dynamic nodes. They are basically multi-hop networks that work without any predetermined infrastructure [7]. Such networks are crucial in areas where communication between wireless devices needs to be present, in spite of the absence of traditional cellular networks. For example, during an emergency disaster relief operation, all traditional communication facilities may be damaged. In such a scenario, the wireless mobile nodes themselves must provide the infrastructure necessary for communication. Mobile ad-hoc networks, due to their inherent dynamic nature, give rise to a variety of problems that are

either new as compared to cellular networks, or old requiring new and varied solutions. Peer-to-peer networks such as [8][1][4][6][16] have recently provided us with different ways in which communication and interaction can take place. Mobile ad-hoc networks and peer-to-peer networks are similar in certain ways. Both paradigms do not require a central infrastructure. There is no hierarchy and all nodes double up as normal nodes as well as routers. Each node is assumed to possess similar resources as compared to the others. Usually broadcast techniques are used in both cases [17][2]. Therefore, basing peer-to-peer applications on top of an ad-hoc network (called mobile peer-to-peer networks) seems to be a natural thing to do. As can be expected, there has been some interesting work that has been done in this direction [3][20][18], and over the years, similar contributions are expected to increase. XML [19] has now become the standard for data representation and exchange. XML is different from traditional data, in that it is semistructured and hierarchical in nature. In our paper, we look at the case of XML data access over mobile peer-to-peer networks. Since network partitions are very frequent in ad-hoc networks (that lay the foundation for mobile peer-to-peer networks), the availability of data becomes a critical parameter. Different replication schemes are usually used in traditional networks. Mobile peer-to-peer networks require slightly different replication strategies. This work is based on quorum based replication methods developed in [22]. The other important issue is to reduce the resources spent in querying XML data over a mobile peer-to-peer network. We use extensions of the classical Bloom filter [21], called Depth and Breadth Bloom filters [24], to decrease query time.

The remainder of the paper is structured as follows. Section 2 looks at the classical Bloom filter and its extensions, Depth and Breadth Bloom filters. In Section 3, we explore the concept of quorum systems. Section 4 introduces N-tier quorum systems and other algorithms that form the main gist of this paper. Simulations are presented in Section 5, followed by the Conclusion in Section 6.

operation on the other BBFis. Thus, BBF0 contains all the labels in the XML tree. For example, consider the XML tree given in figure 1. It represents a set of computational services that are provided to the user.

2. Bloom based filters 2.1 Classical Bloom filters Bloom filters [21] are used to build space-efficient data structures for set membership. Correctness is sacrificed to give preference to space efficiency. They employ a set of hash functions that point to bit positions in a vector. If a particular key is not present, the Bloom filter may give a wrong answer. However, its structure can be tweaked to give a very low probability of failure. Bloom filters have been used in query filtering and routing [28][23], web cache sharing [27] and free text searching [11]. A Bloom filter consists of a bit vector B of m bits and k independent hash functions h1, h2,…..hk. , each with range {1….m}. All bits in B are initialized to 0. In case of insertion, for any ‘x’ from a set X={x1, x2,……xn}, the bit positions at h1(x), h2(x),……hk(x) are turned on, i.e., set to 1. Rest of the bits remain zero. Or, in other words, each hash function maps each ‘x’ to the set Rm = [0,1, ,m-1}. For querying, ‘x’, compute h1(x),h2(x),…..hk(x). If B[h1(x)] = B[h2(x)] =….. =B[hk(x)] = 1, then result is right with a certain probability, else the query return ‘not found’. 2.2 Breadth and Depth Bloom filters Breadth and Depth Bloom filters (BBF and DBF) were proposed in [24]. They are an extension of the classical Bloom filter. Bloom filters cannot handle hierarchical data, such as XML. BBF and DBF have been specially developed to handle this kind of data. 2.2.1 Breadth Bloom filters. Consider an XML tree with j levels. The BBF of the XML tree is a set of Bloom filters {BBF0, BBF1,…..BBFi}, where i <= j. Every level i has an associated Bloom filter BBFi. Every label at level i is hashed to the bit vector of BBFi. The special filter BBF0 is obtained by performing an OR

Figure 2.1

Figure 2.2 Figure 2.2 shows the BBF of the tree in figure 2.1. BBF1, BBF2 and BBF3 bit vectors have been filled by hashing the appropriate labels (shown on the right side of the figure), by using a set of hash functions. The hash functions are not of relevance here, and have not been shown. As can be seen, BBF0 is obtained by ORing BBF1 to BBF3. Querying starts off by checking whether all the labels in the query are present in BBF0. If not, then the result is negative. However, if all labels are present, the path query is checked with the other BBFs. Assume the path query is of type a1/a2/a3/…..ai… Then, each ai is searched in the corresponding BBFi. If all the labels find matches, then the query returns a positive result. 2.2.2 Depth Bloom filters. Depth Bloom filters are similar to Breadth Bloom filters. However, their construction is slightly different. A Depth Bloom Filter consists of a set of Bloom filters {DBF0, DBF1,….DBFi}, i<=j, where j is the number of levels in the XML tree. Each DBFi corresponds to paths of length i. All paths of length i are hashed. The labels belonging to each path is not hashed separately. Instead, their concatenation is hashed as a whole.

The look-up procedure first checks whether all the labels in the query are present in DBF0. If present, all sub-paths of length 2 to c, in the query (of length c) are searched in the corresponding DBFi according to its length.

3 Quorum based strategies Mobile ad-hoc networks usually undergo partitions very frequently, due to the highly dynamic nature of mobile nodes. Dissemination of information is just as important as it is in conventional networks. Ensuring that updates reach the desired nodes may be a problem. On the other hand, ensuring that a query hit receives the latest updates is also not easy to ensure. A tried and tested method is to use data replication, wherein replicas are distributed over nodes. Data replication provides high availability of data in the presence of network failures and partitions [13]. Work on data replication can be found in [5][29][9][10][25]. However, using such elaborate replication strategies in ad-hoc networks actually decrease the availability of data [22]. Furthermore, the communication overhead is usually too high and inappropriate for ad-hoc networks. Karumanchi et al [22] attacks the problem of information dissemination in mobile ad-hoc networks using quorum based replication algorithms that are heuristic in nature. This work adopts their method to increase data availability. The definition of a quorum system as given below: Consider a set of servers S. A quorum system is a set of m subsets of S, called S0, S1,….,Sm-1, such that the union of all subsets equals S, and the intersection of any two subsets is never empty.

4 Proposed solution 4.1 The Bloom Search Tree In this section, we propose Bloom Search Tree (BST) that can be used to perform query operations quickly. Usually, XML queries are represented using XPath[12] or XQuery[26].

Figure 4.1 Consider the DTD tree shown in figure 4.1. An XPath query such as Book[title = ”ad-hoc networks”, year “2000”] // author[ lastname = “manoj”]

=

should retrieve all the books whose title is “ad-hoc networks”, the year of publication is 2000 and the author’s lastname is “Manoj”. Searching through an XML file for the required query can be very time consuming. Instead, we can use Bloom filters to ease the search. Consider figure 4.2, which is what we call a Bloom Search Tree (BST). It is a representation of an XML file that conforms to the DTD shown in figure 4.1. It is similar to the DTD tree, except that the paths that are not present in the XML document are also absent in the BST.

Figure 4.2 Each rectangular block at the leaves in the BST, is an ordered set of Bloom filters, that we call Rectangular Bloom (RB). Each Bloom filter in the RB represents a fragment of the XML file. For example, an XML file may contain information about tens or even hundreds of books. Searching through the XML file for a book with a given title is time consuming. We can decrease search time by representing all the titles by an RB called the RB(title). Suppose there are 25 titles in the XML file. These 25 titles are assigned to 5 groups of 5 titles each in some order (possibly alphabetical). Each title in every group is hashed to a Bloom filter. Thus, all titles from the first group are hashed to the first Bloom filter. Then, those from the second group are hashed to the second Bloom filter, and so on and so forth. All the Bloom filters taken

together form the titleRB. They are denoted by RB(title, 1), RB(title, 2)…….RB(title, n) representing n groups of titles. All the RB(title)s are now ORed together to give RB(title , 0). Thus, every RB(title) consists of Bloom filters RB(title, 0) to RB(title, n). During a search operation, the required title is hashed to a Bloom filter called the queryBloom denoted by QB. QB is first ORed with RB(title, 0). If the OR operation yields RB(title, 0) itself, then there is a high probability that the required title is present in the XML file (remember Bloom filters can generate false positives too, however it’s probability can be tweaked to make it minimal). If the first OR operation succeeds, then QB is ORed with the rest of the filters. QB OR RB(title,i) = RB(title, i)

1 <= i <= n

All the filters that match the condition above represent the fact that the required title may be present in the particular group of titles. For example, if the operation has succeeded for RB(title, 4), it means that the fourth group of titles has a high chance of containing the required title. All RB(title, i)s that did not match the condition will simply not contain the required title, and the corresponding title group need not be searched. Thus, search operations can be speeded up. The pseudocode is given below: Algorithm 4.1 Input: Given BST //query string; eg title = ‘XML’ Query tag //eg title Tag value //eg ‘XML’ bloom b = hash(value); //create Bloom filter //traverse BST to reach node named tag node n = traverseBST(tag) ; RB t = n->RB if !(b OR RB(tag, 0) == RB(tag, 0)) return NOT_FOUND; else { for (int i = 1 ; i <= n ; i++) if (b OR RB(tag, i) == RB(tag, i)) Search for value in the corresponding group of XML fragment Return hits obtained } BST can be used once it is ascertained that all the search paths exist. For example, if the query string contains the path ‘book/preface’, there is no point in

traversing through the BST shown in figure 2, because there is no node called ‘preface’. Even though it may be a part of the DTD, it may not be present in BST, if the XML file does not contain ‘preface’ tags. This is possible because XML is essentially a semi-structured representation of data. To search for paths, such as the above, Breadth and Bloom filters can be used [24]. 4.2 Increasing scalability of XML files As shown in Section 3, quorums can be used as an effective means of data replication in ad-hoc networks, by using certain heuristic approaches [22]. When we talk about XML data specifically, the adhoc network should be scalable with regard to the number of XML files. If the number of XML files in the ad-hoc network increases over time, queries would lead to many XML files being searched, which is not good for scalability. Bloom based filters can be an effective means of performing query. By using a hierarchy of Bloom based filters, the search space can be reduced substantially. In the next few subsections, we will extend the notion of a quorum system to what we call N-tier quorum system. 4.2.2 N-tier quorum system. The definition of a quorum system was given in Section 3. Let us now look at how we can create a hierarchy of quorum systems: Given a set S of servers, an N-tier quorum system is an ordered set of quorum systems. The subsets and the number of subsets of each quorum system may differ from one another. The different quorum systems are called 0-tier, 1-tier, 2-tier…..ntier. Using Breadth and Depth Bloom filters to search for a certain set of services in a network, has been dealt with in [24]. However, such methods cannot be applied directly to mobile peer-to-peer networks, due to the highly dynamic nature of nodes. Some form of replication is needed. One way to tackle the problem is by combining the ideas of Bloom based filters and quorum systems. The former would give enhanced scalability with respect to number of XML files, and the later would increase availability, two very important parameters that need to be optimized in mobile peer-peer networks. 4.2.3 Update operations. Consider a new XML file that needs to be updated to the mobile peer-to-peer network. The concerned node x can perform the updation by using the STE, ETS or Hybrid algorithm given in [22], and the same have been used in the simulations. However, for the sake of simplicity, let us avoid the heuristic algorithms for the moment,

and use the simple quorum based scheme. Node x can perform two kinds of update: adding a new file or modifying an existing file. Let us consider the addition of a new file first.

21: 22:

b_old = create_ORed_BBF (old_grp); b_new = create_ORed_BBF (grp);

23: 24:

tier = tier + 1; grp = get_group(tier, b_old);

Algorithm 4.2 //for the node creating the XML file Input: 1: XML_file X

25: 26:

Procedure: 2: BST = compute_bloom_search_tree(X); 3: BBF = compute_breadth_bloom_filter(X); 4: T = create_timestamp(); 5: Q = select_quorum(0-tier); 6: send( Q, T, X, BST, BBF); Algorithm 4.3 //for nodes in the quorum receiving the update Input: 1: XML_file X; 2: bloom_search_tree BST; 3: breadth_bloom_filer BBF; 4: timestamp T; Procedure: 5: add_to_BST_repository(BST, T, 0); 6: add_to_XML_repository(X, T, 0); 7: add_to_BBF_repository(BBF, T, 0);

Procedure add_to_BBF_repository(BBF, T, tier); { 8: given no_of_groups; 9: given group_size; 10: given no_of_BBFs; 11: grp = select_group(); 12: if (grp == -1) //no empty group { //split a group 13: grp1 = select_full_group(); 14; split (grp1, grp2,grp3); 15: add_BBF (grp2, BBF, T); 16: notify_next_tier (grp1, grp2,grp3); } 17: else { 18: old_grp = grp; 19: add_BBF (grp, BBF, T); 20: notify_next_tier(old_grp, grp); } procedure notify_next_tier(old_grp, grp) {

remove_from_BBF_repository(b_old, tier); add_to_BBF_repository ( b_new, T, tier); }

procedure notify_next_tier (grp1, grp2,grp3) { //overloaded function 28: b_old = create_ORed_BBF (grp1); 29: b_new1= create_ORed_BBF (grp2); 30: b_new2= create_ORed_BBF (grp3); 31: 32: 33: 34: 35:

tier = tier +1; grp = get_group(tier, b_old); remove_from_BBF_repository(b_old, tier); add_to_BBF_repository ( b_new1, T, tier); add_to_BBF_repository ( b_new2, T, tier);

} Considering algorithm 4.2, a node x first creates the BST of the XML file and the BBF(or DBF) representing the paths in the XML file(lines 2 and 3). It then randomly chooses a quorum belonging to 0tier(line 5). The XML file as well as the BST and BBF are sent to all nodes in the selected quorum, along with a timestamp.(line 6) From now onwards we only mention BBF. However, the operations apply equally well if DBF is used). Since the underlying network is highly dynamic, some nodes belonging to the quorum may not receive the new file. The quorum on receiving the three data, adds them to its existing data (algorithm 4.3, lines 5,6,7). When we say that the quorum receives the datum, we mean that all the nodes in the quorum reachable from x, receive the datum, and add it to their local data. After this stage, only the BBF remains in the picture. Every quorum divides the BBFs it contains into groups. Each group has a maximum size called group_size. As more and more BBFs are added to the quorum, the number of groups also increases. Whenever a group reaches its full capacity, i.e., number of BBFs = group_size, it is split into two groups containing one half of the BBFs in the original group (lines 13-16). All the BBFs in each group are ORed together and the resulting BBF is sent to a randomly chosen quorum in the next tier. The ORing operation happens whenever the contents of a group are modified due to a change in one the BBFs or due to the addition of a new BBF. When a group splits, the two resulting groups OR their

respective BBFs and the resulting two BBFs are sent to the next tier. The original ORed BBF present in the next tier is replaced with the incoming new BBFs. The process is recursive, and take place in all the tiers.(lines 28-35) Figure 4.3 illustrates the addition of an XML file. As can be seen in figure 4.3, addition of an XML file is accompanied by the addition of its BST and BBF. The BBFs in the quorum are divided into groups. All the BBFs in a group are ORed together to give a BBF that is sent to the next level. Modifying an XML file is similar to adding a file. The only difference is that the corresponding BST and BBF have to be modified. On modifying the BBF in 0-tier, the modifications have to be propagated to the higher tiers.

Figure 4.3 The node that creates the XML file, sends the BST and BBF to the selected quorum, and then waits for acknowledgements. The acknowledgements would indicate the nodes that can be reached by the creator node. The creator node then randomly chooses one of the nodes (that sent an acknowledgement), to execute algorithm 4.3. If at all any modifications have been made to the N-tier structures, notifications can be send to the rest of the nodes in the quorum.. Algorithm 4.3 //query Input: 1: Query q; 2: extract_paths(q);

3: bloom b; 4: for each extracted path do 5: queryBBF = hash(queryBBF, path); 6: q=select_quorum(n);

//from n-tier

7: for all BBFs in q do 8: if(queryBBF OR BBF == BBF) { 9: grp =get_group_lower_tier(BBF) 10: for all BBFs in grp do 11: perform step 8 - 11 recursively till 0-tier is reached } 12: if(0-tier) { 13: XML_fragments = search_BST(); 14: for all XML_fragments do 15: search () } 4.2.4 Query operations. All paths are first extracted from a given query. They are then hashed to a BBF called the queryBBF (lines 2-5). The queryBBF is then directed to the highest numbered tier : n-tier. A quorum is randomly chosen (line 6) and the queryBBF is ORed with all the BBFs present in the quorum. If the OR operation yields the latter BBF itself, then a query hit at the ith tier (0<= i <= n) is said to have taken place (line 8). The result of a query hit at i-tier, is one of the BBFs in the selected quorum. This BBF is actually a resultant of an OR operation performed on BBFs in a group in the (i-1)tier. The query is now directed to the concerned quorum and group, whose BBFs were ORed together to give the query hit BBF in the tier above. This operation is performed recursively, till 0-tier is reached (lines 9-11). Reaching 0-tier means that the required path has been found. Now the tag values present in the query, such as title = ‘’XML” are hashed to individual Bloom filters. Each Bloom filter is now searched in RBs present at the leaves of the BST. On getting a hit, the corresponding XML fragment is searched to finally provide the result of the original query(lines 13-15).

5 Simulation Simulation was done by considering a set of 100 nodes. Each node was initially assigned a location in a square area of length 1000 units. Every node had an associated variable called static_duration, during which the node remained statically in the same position. Static_durantion was randomly assigned

(static_durantion <10). After every time unit, a check was made to see whether any node had completed it’s static_duration. If yes, then a new location was randomly assigned within a circle of 75 units from the prior location. Since the underlying network was a mobile peer-to-peer network, any node could update or query XML tables. Update and query operations could be made randomly by any node in the network, and are heuristic in nature [22]. As can be seen in figure 5, the number of XML files is exponential with respect to the number of tiers. That is, even with a huge increase in the number of XML files generated by the mobile peerto-peer network, the number of tiers in an N-tier quorum remains very small. Each tier adds an additional set of BBFs to compare with. For example, for a 3-tier quorum system and group sizes of 4 per quorum, the number of BBFs to be compared would be equal to

no. of XML files

40000 30000 size 4 20000

6 Conclusion In this paper we have tried to attack the problem of accessing XML data in a mobile peer-to-peer network. Because nodes in such a network are very dynamic, leading to frequent network partitions, we have used quorums for data replication, in order to increase availability. If the number of XML files generated increases to huge numbers, then computing queries become inefficient. In order to decrease the search space, we have used Breadth and Depth Bloom filters. In order to apply such features in the presence of replication, we have extended the classic quorum system to what we call N-tier quorum system.

size 8 size 12

10000

num ber of tiers

Figure 5.1 the number of BBFs in tier 3 plus 12. This is because all the BBFs in tier 3 have to be compared to fish out the matching filter. Once this is done, the search is redirected to the group (in the lower tier) representing the BBF. If the number of BBFs per group is four, then 0-tier, 1-tier and 2-tier contribute four each giving twelve filters.

60 50 40

size 4

30

size 8

20

size 12

10 0 number of tiers

Figure 5.2

7 References [1]Druschel, P., and Rowstron, A., “Past: Persistent and anonymous storage in a peer-to-peer networking environment”, In Proceedings of the 8th IEEE Workshop on Hot Topics in Operating Systems Elmau/Oberbayern, Germany, May 2001, pp. 65–70.

0

no. of BBFs to be searched

Figure 6 shows the number of BBFs that need to be compared with a query BBF, with respect to the number of tiers. Since the relationship is linear, the relationship between the number of XML files and the number of BBFs to be compared, is exponential. In other words, in spite of a huge increase in the number of XML files, the number of BBFs to compared with a query BBF is very small.

[2]A. Pava. Gnutella is dead. ZDNet Music, 2000. http://music.zdnet.com/features/ highnote/092100_gnutella_dead.html. [3]G. Cugola and G. Picco. “PeerWare: Core Middleware Support for Peer-To-Peer and Mobile Systems”, Technical report, Politecnico di Milano, May 2001. Submitted for Publication [4]Kubiatowicz, J., Bindel, D., Chen, Y., Czerwinski, S., Eaton, P., Geels, D., Gummadi, R., Rhea, S., Weatherspoon, H., Weimer, W., Wells, C., and Zhao, B, “OceanStore: An architecture for global-scale persistent storage”, In Proceeedings of the Ninth international Conference on Architectural Support for Programming Languages and Operating Systems, Boston, MA, November 2000, pp. 190–201. [5]D.K. Gfifford, “Weighted Voting for Replicated Data”, In Proceedings of the 7th Symposium on Operating Systems Principles, 162, ACM, 1979, pages 150 [6]Ratnasamy, S., Francis, P., Handley, M., Karp, R., and Shenker, S, “A scalable content-addressable

network”, In Proc. ACM SIGCOMM ,San Diego, CA, August 2001. [7] Z. Haas, et. al., “Guest Editorial on Wireless Ad HocNetworks”, IEEE Journal on Selected Areas in Communications, Vol. 17 No. 8,August 1999. [8]Clarke, I., Sandberg, O., Wiley, B., and Hong, T. W, “Freenet: A distributed anonymous information storage and retrieval system”, In Proceedings of the ICSI Workshop on Design Issues in Anonymity and Unobservability Berkeley, California, June 2000. http://freenet.sourceforge.net.

[19]T. Bray, J. Paoli, C. Sperberg-McQueen, “Extensible Markup Language” http://www.w3.org/XML/1998/06/xmlspecreport.htm [20] C. Mascolo, L. Capra, and W. Emmerich, “An XMLbased Middleware for Peer-to-Peer Computing”, In Proc. of the International Conference on Peer-toPeer Computing (P2P2001), Link¨oping, Sweden, Aug. 2001. [21] Burton Bloom, “Space/time trade-offs in hash coding with allowable errors”, Communications of the ACM, pages 13(7): 422-426, July 1970.

[9]S. Jajodia and D. Mutchler. Integrating Static and Dynamic Voting Protocols to Enhance File Availability. In Proceedings of the 4th International Conference on Data Engineering, pages 144{153. IEEE, 1988.

[22] Gautham Karumanchi, Srinivasan Muralidharan and Ravi Prakash, “Information Dissemination in Partitionable Mobile Ad Hoc Networks”,Proceedings of IEEE Symposium on Reliable Distributed Systems, Lausanne, Switzerland, Pages 4--13, October 19--22, 1999.

[10]D. Barbara, H. Garcia-Molina, and A. Spauster, “ In creasing Availability Under Mutual Exclusion Constraints with Dynamic Vote Reassignment”, ACM Transactions on Computer Systems, 7(4):394{426, No vember 1989.

[23]Fan, L., Cao, P., Almeida, J., and Broder, A, “Summary cache: A scalable wide-area Web cache sharing protocol”, In Proceedings of ACM SIGCOMM Conference, pages 254–265, Sept. 1998.

[11]Ramakrishna, M.V, “Practical performance of Bloom Filters and parallel free-text searching”, Communications of the ACM, 32 (10). 1237-1239.

[24]Georgia Koloniari, Evaggelia Pitoura, ‘BloomBased Filters for Hierarchical Data”, 5th Workshop on distributed data structures and algorithm, July 2003

[12]J. Clark and S. DeRose, “ XML Path Language (XPath) version 1.0”, W3C recommendation, 1999.

[25]M. Herlihy, “ Dynamic Quorum Adjustment for Partitioned Data”, ACM Transactions on Database Systems 12(2):170{194, June 1987.

[13]S.B. Davidson, H. Garcia-Molina, and D. Skeen, “Consistency in Partitioned Networks”, ACM Computing Surveys, 17(3):341{370, September 1985. [14] C. Tschudin, H. Lundgren, and H. Gulbrandsen, “Active Routing for Ad-Hoc Networks”, IEEE Communications Magazine, pages 122–127, 2000. [15] I. M. W. Group. MANET Charter, 2000. http://www.ietf.org/html.charters/ manet-charter.html. [16]I. Stoica, R. Morris, D. Karger, M. F. Kaashoek, and H. Balakrishnan, “ Chord: A scalable peer-to-peer lookup service for Internet applications”, In Proc. ACM SIGCOMM’01, San Diego, CA, Aug. 2001. [17]S.-Y. Ni, Y.-C. Tseng, Y.-S. Chen, and J.-P. Sheu, “The broadcast storm problem in a mobile ad-hoc network”, In Mobicom’99, 1999. http://www.acm.org/pubs/articles/proceedings/comm/ 313451/p151-ni/p151-n%i.pdf. [18] P. Charas, “ Peer-to-Peer Mobile Network Architecture”, In Proc. of the International Conference on Peer-to-Peer Computing (P2P2001), Link¨oping, Sweden, Aug. 2001.

[26]D. Chamberlin, D. Florescu, J. Robie, J. Simon, and M. Stefanescu, “XQuery: A Query Language for XML”, W3C working draft, 2001. [27] Hodes, T.D., Czerwinski, S.E., Zhao, B.Y., Joseph, A.D. and Katz, R.H, “ An Architecture for Secure WideArea Service Discovery”, Proceedings of the 5th Annual ACM/IEEE International Conference on Mobile Computing and Networking `99, Seattle, Washington, 15-19 August, pp. ~24-35. ACM Press New York, NY, USA.. [28]Gribble, S.D., Brewer, E.A., Hellerstein, J.M. and Culler D., “Scalable Distributed Data Structures for Internet Service Construction”, In Proceedings of the Fourth Symposium on Operating Systems Design and Implementation, San Diego, CA, 2000. [29]J.-F. Paris and D.D.E. Long, “Efficient Dynamic Voting Algorithms”, In Proceedings of the 4th International Conference on Data Engineering, pages 268 275. IEEE, 1988.