Section: New Results
Distributed data management
In a large scale distributed system, data sources are typically in high numbers, autonomous (under strict local control) and very heterogeneous in size and complexity. Data management in this context offers new research opportunities since traditional distributed database techniques need to scale up while supporting high data autonomy, heterogeneity, and dynamicity.
We are interested in database clusters and peer-to-peer (P2P) systems which are good examples of large-scale distributed systems of high practical interest. However, to yield general results, we strive to develop common algorithmic solutions with the right level of abstraction from the context. In 2006, we continued our work on data management in P2P systems with the design of Atlas Peer-to-Peer Architecture (APPA) with new techniques for distributed reconciliation of replicated data and top-k query processing. We have also proposed a new query load balancing strategy.
Design of APPA
APPA (Atlas Peer-to-Peer Architecture) is a new P2P data management system which we are building  ,  . Its main objectives are scalability, availability and performance for advanced applications. These applications must deal with semantically rich data (e.g., XML documents, relational tables, etc.) using a high-level SQL-like query language. As a potential example of advanced application that can benefit from APPA, consider the cooperation of scientists who are willing to share their private data (and programs) for the duration of a given experiment. The main originality of APPA's architecture is to be network-independent and organized in terms of basic and advanced services that can be implemented over different P2P networks (unstructured, DHT, super-peer, etc.).. This allows us to exploit continuing progress in such systems. To deal with semantically rich data, APPA supports decentralised schema management, data replication and updates, query processing and load balancing.
We have started the implementation of APPA using the JXTA framework. APPA's advanced services are provided as JXTA community services. Only the P2P network layer of the APPA implementation depends on the JXTA platform. Thus, APPA is portable and can be used over other platforms by replacing the services of the P2P network layer. We validated some of APPA's services on the cluster of Paris team at INRIA, which has 64 nodes. Additionally, in order to study the scalability of these services with larger numbers of nodes, we implemented simulators using Java and SimJava. The current version of the APPA prototype and its service simulators manage data using a Chord DHT. Experimental results showed that simulators are well calibrated and the implemented services have good performance and scale up. Implementing on top of JXTA was relatively easy, but we faced some problems to adapt JXTA core services and to deploy the APPA prototype for tests using the JXTA framework.
Distributed Reconciliation in APPA
An important aspect of collaborative applications is that users may perform updates and may join and leave the network whenever they wish, thus hurting data availability. Data replication can then be used to increase availability. Lazy master replication is not applicable in P2P because a single master peer hurts availability. Thus, we focus on a multi-master approach in which all peers may update replicated data. In particular, we are interested in optimistic solutions based on semantic reconciliation, because it provides more flexibility and supports connections and disconnections. Existing semantic reconciliation solutions are typically performed at a single peer which may become a bottleneck in a large-scale system. In  , we proposed a Distributed Semantic Reconciliation Algorithm (DSR) that enables optimistic multi-master replication and assures eventual consistency among replicas. DSR works in the context of APPA system. The DSR/APPA integration is presented in  .
The P2P network costs incurred in data accesses may vary significantly from node to node and have a strong impact on the reconciliation performance. Thus, network costs should be considered to perform reconciliation efficiently. In  , we proposed the P2P-reconciler protocol that extends DSR by providing a cost model for selecting reconciler nodes based on network latencies. For computing communication costs, P2P-reconciler uses local information and deals with the dynamic behavior of nodes. It also limits the scope of event propagation (e.g. joins or leaves) in order to avoid network overload. The cost model was improved in  by taking into account different bandwidths and data transfer costs. We proved the algorithms' correctness and validated them through implementation and simulation. The experimental results showed that cost-based reconciliation outperforms a random approach for selecting reconciler nodes by a factor of 26. In addition, the number of connected nodes does no affect the performance of cost-based reconciliation since the reconciler nodes are as close as possible to data accessed in the reconciliation. Compared with a centralized solution, our algorithm yields high data availability and excellent scalability, with acceptable performance and limited overhead.
Top-k query processing in APPA
High-level queries over a large-scale P2P system may produce very large numbers of results that may overwhelm the users and generate heavy network traffic. This is caused mainly by high numbers of query answers, many of which are irrelevant for the users. One solution to this problem is to use Top-k queries whereby the user can specify a limited number (k) of the most relevant answers. In  , we proposed FD, a (Fully Distributed) framework for executing Top-k queries in unstructured P2P systems, with the objective of reducing network traffic. FD consists of a family of algorithms that are simple but effective. FD is completely distributed, does not depend on the existence of certain peers, and addresses the volatility of peers during query execution. We validated FD through implementation over a 64-node cluster and simulation using the BRITE topology generator and SimJava. Our performance evaluation shows that FD can achieve major performance gains in terms of communication and response time.
In  , we considered the problem of top-k query processing in Distributed Hash Tables (DHTs). The most efficient approaches for top-k query processing in centralized and distributed systems are based on the Threshold Algorithm (TA) which is applicable for queries where the scoring function is monotone. However, the specific interface of DHTs, i.e. data storage and retrieval based on keys, makes it hard to develop TA-style top-k query processing algorithms. We proposed an efficient mechanism for top-k query processing in DHTs. Although our algorithm is TA-style, it is much more general since it supports a large set of non monotone scoring functions including linear functions. In fact, it is the first TA-style algorithm that supports linear scoring functions. We proved analytically the correctness of our algorithm and validated it through a combination of implementation and simulation. The results show very good performance, in terms of communication cost and response time.
Query load balancing in large-scale distributed systems
We consider dynamic distributed systems, providing access to large numbers of heterogeneous, autonomous information sources  . We assume that information sources play basically two roles: consumers that generate queries and providers which perform requests and generate informational answers. In this context, we considered the query allocation problem. Provider sources are heterogeneous, autonomous, and have finite capacity to perform queries. A main objective in query allocation is to obtain good response time. Most of the work towards this objective has dealt with the problem of balancing the query load among providers. But little attention has been paid to satisfy the providers'interests in performing certain queries. In  , we addressed both sides of the problem. We proposed a query allocation process which allows providers to express their intention to perform queries based on their preference and satisfaction. We compared our solution to both query load balancing and economic approaches. The experimentation results show that our approach yields high efficiency while supporting the providers' preferences in adequacy with the query load. Also, we showed that our approach guarantees interesting queries to providers even under low arrival query rates. In the context of open distributed systems, our solution outperforms traditional query load balancing approaches as it encourages providers to stay in the system, thus preserving full system capacity.