Showing papers presented at "ACM/IFIP/USENIX international conference on Middleware in 2004"

The peer sampling service: experimental evaluation of unstructured gossip-based implementations

Abstract: In recent years, the gossip-based communication model in large-scale distributed systems has become a general paradigm with important applications which include information dissemination, aggregation, overlay topology management and synchronization. At the heart of all of these protocols lies a fundamental distributed abstraction: the peer sampling service. In short, the aim of this service is to provide every node with peers to exchange information with. Analytical studies reveal a high reliability and efficiency of gossip-based protocols, under the (often implicit) assumption that the peers to send gossip messages to are selected uniformly at random from the set of all nodes. In practice -- instead of requiring all nodes to know all the peer nodes so that a random sample could be drawn -- a scalable and efficient way to implement the peer sampling service is by constructing and maintaining dynamic unstructured overlays through gossiping membership information itself.This paper presents a generic framework to implement reliable and efficient peer sampling services. The framework generalizes existing approaches and makes it easy to introduce new ones. We use this framework to explore and compare several implementations of our abstraction. Through extensive experimental analysis, we show that all of them lead to different peer sampling services none of which is uniformly random. This clearly renders traditional theoretical approaches invalid, when the underlying peer sampling service is based on a gossip-based scheme. Our observations also help explain important differences between design choices of peer sampling algorithms, and how these impact the reliability of the corresponding service.

Meghdoot: content-based publish/subscribe over P2P networks

Abstract: Publish/Subscribe systems have become a prevalent model for delivering data from producers (publishers) to consumers (subscribers) distributed across wide-area networks while decoupling the publishers and the subscribers from each other. In this paper we present Meghdoot, which adapts content-based publish/subscribe systems to Distributed Hash Table based P2P networks in order to provide scalable content delivery mechanisms while maintaining the decoupling between the publishers and the subscribers. Meghdoot is designed to adapt to highly skewed data sets, which is typical of real applications. The experimental results demonstrate that Meghdoot balances the load among the peers and the design scales well with increasing number of peers, subscriptions and events.

Ganymed: scalable replication for transactional web applications

Abstract: Data grids, large scale web applications generating dynamic content and database service providing pose significant scalability challenges to database engines. Replication is the most common solution but it involves difficult trade-offs. The most difficult one is the choice between scalability and consistency. Commercial systems give up consistency. Research solutions typically either offer a compromise (limited scalability in exchange for consistency) or impose limitations on the data schema and the workload. In this paper we introduce Ganymed, a database replication middleware intended to provide scalability without sacrificing consistency and avoiding the limitations of existing approaches. The main idea is to use a novel transaction scheduling algorithm that separates update and read-only transactions. Transactions can be submitted to Ganymed through a special JDBC driver. Ganymed then routes updates to a main server and queries to a potentially unlimited number of read-only copies. The system guarantees that all transactions see a consistent data state (snapshot isolation). In the paper we describe the scheduling algorithm, the architecture of Ganymed, and present an extensive performance evaluation that proves the potential of the system.

Interoperability among independently evolving web services

Abstract: The increasing popularity of XML Web services motivates us to examine if it is feasible to substitute one vendor service for another when using a Web-based application, assuming that these services are "derived from" a common base. If such substitution were possible, end users could use the same application with a variety of back-end vendor services, and the vendors themselves could compete on price, quality, availability, etc. Interoperability with substituted services is non-trivial, however, and four types of incompatibilities may arise during such interoperation -- structural, value, encoding and semantic. We address these incompatibilities three-fold: (1) static and dynamic analysis tools to infer whether an application is compatible with a substituted service, (2) semi-automatically generated middleware components called cross-stubs that actually resolve incompatibilities and enable interoperation with substituted services, and (3) a lightweight mechanism called multi-option types to enable applications to be written from the ground up in an interoperation-friendly manner. Using real applications and services as examples, we both demonstrate and evaluate our tools and techniques for enabling interoperation with substituted services.

MiddleWhere: a middleware for location awareness in ubiquitous computing applications

Abstract: Location awareness significantly enhances the functionality of ubiquitous computing services and applications, and enriches the way they interact with users and resources in the environment. Many different alternative or complementary location sensing technologies are available. However, these technologies give location information in different formats and with different resolution and confidence. In this paper we introduce "MiddleWhere" a distributed middleware infrastructure for location that separates applications from location detection technologies. MiddleWhere enables the fusion of different location sensing technologies and facilitates the incorporation of additional location technologies on the fly as they become available. MiddleWhere utilizes probabilistic reasoning techniques to resolve conflicts and deduce the location of people given different sensor data. Besides, it allows applications to determine various kinds of spatial relationships between mobile objects and their environment, which is key in enabling a strong coupling between the physical and virtual world, as emphasized by ubiquitous computing. We have integrated MiddleWhere with our ubiquitous computing infrastructure, and have verified its flexibility and usefulness by incorporating various location sensing technologies and building a number of location-sensitive applications on top of it.

Composition of coordinated web services

Abstract: The Web services architecture defines separate specifications for the composition and the coordination of Web services. BPEL is a language for creating service compositions in the form of business processes, whereas the WS-Coordination framework defines coordination protocols for distributed activities. In this paper, we investigate the combination of these two aspects to compose coordinated Web services. We argue for a policy-based approach to address this problem and introduce a new model and middleware that enables the flexible integration of diverse coordination types into (existing) process-based Web services compositions.

An ontology-based publish/subscribe system

Abstract: Expressiveness and matching efficiency are two key design goals of publish/subscribe systems. In this paper, we introduce the Semantic Web technologies into the publish/subscribe system and propose an ontology-based publish/subscribe (OPS) system. The system can make use of the semantic of events to match events with subscriptions, and can support events with complex data structure (such as graph structure). An efficient matching algorithm is proposed for the OPS system, which can match events with subscriptions in a speed much higher than conventional graph matching algorithms. Therefore, the main contribution of our work is that it greatly improves the expressiveness of the publish/subscribe system without the sacrifice of matching efficiency.

Directed flood-routing framework for wireless sensor networks

Abstract: The directed flood-routing framework (DFRF) for wireless sensor networks is introduced in this paper that allows the modeling and rapid development of application specific routing protocols based on directed flooding Flood-routing protocols are probabilistic methods that make only the best effort to route data packets The presented family of protocols can route regular sized data packets via broadcast messages according to customizable, state machine based routing policies that govern the way intermediate nodes rebroadcast messages The framework supports automatic data packet aggregation, and allows in-network data packet filtering and alteration

Adaptive middleware for data replication

Abstract: Dynamically adaptive systems sense their environment and adjust themselves to accommodate to changes in order to maximize performance. Depending on the type of change (e.g., modifications of the load, the type of workload, the available resources, the client distribution, etc.), different adjustments have to be made. Coordinating them is already difficult in a centralized system. Doing so in the currently prevalent component-based distributed systems is even more challenging. In this paper, we present an adaptive distributed middleware for data replication that is able to adjust to changes in the amount of load submitted to the different replicas and to the type of workload submitted. Its novelty lies in combining load-balancing techniques with feedback driven adjustments of multiprogramming levels (number of transactions that are allowed to execute concurrently). An extensive performance analysis shows that the proposed adaptive replication solution can provide high throughput, good scalability, and low response times for changing loads and workloads with little overhead.

Developing and managing software components in an ontology-based application server

Abstract: Application servers provide many functionalities commonly needed in the development of a complex distributed application. So far, the functionalities have mostly been developed and managed with the help of administration tools and corresponding configuration files, recently in XML. Though this constitutes a very flexible way of developing and administrating a distributed application, e.g. an application server with its components, the disadvantage is that the conceptual model underlying the different configurations is only implicit. Hence, its bits and pieces are difficult to retrieve, survey, check for validity and maintain. To remedy such problems, we here present an ontology-based approach to support the development and administration of software components in an application server. The ontology captures properties of, relationships between and behaviors of the components that are required for development and administration purposes. The ontology is an explicit conceptual model with formal logic-based semantics. Therefore its descriptions of components may be queried, may foresight required actions, e.g. preloading of indirectly required components, or may be checked to avoid inconsistent system configurations -- during development as well as during run time. Thus, the ontology-based approach retains the original flexibility in configuring and running the application server, but it adds new capabilities for the developer and user of the system. The proposed scheme has been prototypically implemented in KAON SERVER, an application server running components that support a range of various semantic technologies -- thus applying semantic technologies to itself.

Extending a J2EE™ server with dynamic and flexible resource management

Abstract: The Java™ 2 Platform, Enterprise Edition (J2EE™) is the standard platform for hosting enterprise applications written in the Java programming language. A single J2EE server can support multiple applications much like a traditional operating system, but performance levels can be difficult to control, due to the absence of resource management facilities in the Java platform. The Resource Management (RM) interface addresses this problem by providing a flexible and extensible framework for managing resources that is applicable across a broad spectrum, from low-level resources like CPU time to higherlevel resources such as database connections. RM has been implemented in the Multi-tasking Virtual Machine (MVM), a scalable operating environment for multiple applications based on the concept of isolated computations. This paper describes the application of MVM and RM to the management of resources in a J2EE Server and shows that application performance can be controlled flexibly and easily with low overhead and minimal intrusion.

Subscription propagation in highly-available publish/subscribe middleware

Abstract: Achieving availability and scalability while providing service guarantees such as in-order, gapless delivery is essential for deploying publish/subscribe messaging middleware in wide area networks. Scalability often requires a publish/subscribe system to propagate subscription information and perform content matching across the network. Existing subscription propagation algorithms do not support in-order, gapless delivery in a redundant overlay network.This paper presents a novel approach that utilizes virtual time (VT) vectors to convey temporal consistency in propagating incremental and consolidated subscription information. The VT vectors provide a means of testing sufficiency of filtering information, by comparing a broker's VT vector with that of a message. When the test fails, indicating insufficient broker subscription information, safety may be preserved by "flooding" the message to all neighbors on a routing tree. This approach does not require subscription state agreement across redundant paths and hence is highly available. We present a detailed evaluation of the approach.

Dynamically programmable and reconfigurable middleware services

Abstract: The increasing software complexity and proliferation of distributed applications for cell phones demand the introduction of middleware services to assist in the development of advanced applications. However, from the user perspective, it is essential that these new phones provide a smooth error-free experience. Despite of the complexity underlying a cell phone, placing a phone call remains a simple task that can be performed by most users regardless of their technical background. Furthermore, cell phones rarely crash (especially compared to PCs) and carriers are able to correct certain problems remotely without user intervention.We advocate for a middleware infrastructure that allows carriers and developers to correct middleware behavior, configure it, and upgrade it, without requiring user intervention and without stopping the execution of applications. We introduce a new technique we refer to as externalization. This technique explicitly externalizes the state, the logic, and the internal component structure of middleware services. As a result, carriers and developers have full control over these middleware services. They can access, inspect, and modify the state, logic, and structure of middleware services at runtime while preserving the execution of existing applications and providing an error-free experience to users. We claim that externalization is the key for the future evolution of cell phones' middleware infrastructure.

iOverlay: a lightweight middleware infrastructure for overlay application implementations

Abstract: The very nature of implementing and evaluating fully distributed algorithms or protocols in application-layer overlay networks involves certain programming tasks that are at best mundane and tedious -- and at worst challenging -- even at the application level. In this paper, we present iOverlay, a lightweight and high-performance middleware infrastructure that addresses these problems in a novel way by providing clean, well-documented layers of middleware components. The internals of iOverlay are carefully designed and implemented to maximize its performance, without sacrificing the simplicity of application implementations using iOverlay. We illustrate the effectiveness of iOverlay by rapidly implementing a set of overlay applications, and report our findings and experiences by deploying them on PlanetLab, the wide-area overlay network testbed that iOverlay conveniently supports.

Platform independent model transformation based on triple

Abstract: Reuse is an important topic in software engineering as it promises advantages like faster time-to-market and cost reduction. Reuse of models on an abstract level is more beneficial than on the code level, because these models can be mapped into several technologies and can be adapted according to different requirements. Unfortunately, development tools only provide fixed mappings between abstract models described in a language such as UML and source code for a particular technology. These mappings are based on one-to-one relationships between elements of both levels. As a consequence, it is rarely possible to customize mappings according to specific user requirements.We aim to improve model reuse by providing a framework that generates customized mappings according to specified requirements. The framework is able to handle mappings aimed for several component technologies as it is based on an ADL. It is realized in Triple to represent components on different levels of abstraction and to perform the actual transformation. It uses feature models to describe mapping alternatives.

On exploring performance optimizations in web service composition

Abstract: The importance of service composition has been widely recognized in the Internet research community due to its high flexibility in allowing development of customized applications from primitive services in a plug-and-play manner. Although much research in defining architectures, choreography languages and etc, has been conducted, little attention has been paid to composite services' runtime performance-related aspects (e.g., network bandwidths, path delay, machine resources), which are of great importance to wide-area applications, especially those that are resource-consuming. Service composition in the wide area actually creates a new type of routing problem which we call QoS service routing. We study this problem in large networks and provide distributed and scalable routing solutions with various optimization goals. Most importantly, we propose ways to reduce redundancies in data delivery and service execution through explorations of different types of multicast (service multicast and data multicast) in one-to-many application scenarios.

Foreseer: a novel, locality-aware peer-to-peer system architecture for keyword searches

Abstract: Peer-to-peer (P2P) systems are becoming increasingly popular and complex, serving millions of users today. However, the design of current unstructured P2P systems does not take full advantage of rich locality properties present in P2P system workloads, thus possibly resulting in inefficient searches or poor system scalability. In this paper, we propose a novel locality-aware P2P system architecture called Foreseer, which explicitly exploits geographical locality and temporal locality by constructing a neighbor overlay and a friend overlay respectively. Each peer in Foreseer maintains a small number of neighbors and friends along with their content filters used as distributed indices. By combining the advantages of distributed indices and utilization of two-dimensional localities, the Foreseer search scheme satisfies more than 99% of keyword search queries and realizes very high search performance, with a low maintenance cost. In addition, query messages rarely touch free-riders, and therefore avoid most meaningless messages inherent in unstructured P2P systems. Our simulation results show that, compared with current unstructured P2P systems, Foreseer boosts search efficiency while adding only modest maintenance costs.

SyD: a middleware testbed for collaborative applications over small heterogeneous devices and data stores

Abstract: Developing a collaborative application running on a collection of heterogeneous, possibly mobile, devices, each potentially hosting data stores, using existing middleware technologies such as JXTA, BREW, compact .NET and J2ME requires too many ad-hoc techniques as well as cumbersome and time-consuming programming. Our System on Mobile Devices (SyD) middleware, on the other hand, has a modular architecture that makes such application development very systematic and streamlined. The architecture supports transactions over mobile data stores, with a range of remote group invocation options and embedded interdependencies among such data store objects. The architecture further provides a persistent uniform object view, group transaction with Quality of Service (QoS) specifications, and XML vocabulary for inter-device communication. This paper presents the basic SyD concepts and introduces the architecture and the design of the SyD middleware and its components. We also provide guidelines for SyD application development and deployment process. We include the basic performance figures of SyD components and a few SyD applications on Personal Digital Assistant (PDA) platforms. We believe that SyD is the first comprehensive working prototype of its kind, with a small code footprint of 112 KB with 76 KB being device-resident, and has a good potential for incorporating many ideas for performance extensions, scalability, QoS, workflows and security.

Portable and efficient distributed threads for Java

Abstract: Java middleware mechanisms, such as Java RMI or CORBA implementations, do not support thread coordination over the network: synchronizing on remote objects does not work correctly and thread identity is not preserved for executions spanning multiple machines. The current approaches dealing with the problem suffer from one of two weaknesses: either they require a new middleware mechanism, making them less portable, or they add overhead to the execution to propagate a thread identifier through all method calls. In this paper we present an approach that works with an unmodified middleware implementation, yet does not impose execution overhead. The key to our technique is the bytecode transformation of only stub routines, instead of the entire client application. We argue that this approach is portable and can be applied to mostly any middleware mechanism. At the same time, we show that, compared to past techniques, our approach eliminates an overhead of 5.5-12 applications from the SPEC JVM suite.

Guiding queries to information sources with InfoBeacons

Abstract: The Internet provides a wealth of useful information in a vast number of dynamic information sources, but it is difficult to determine which sources are useful for a given query. Most existing techniques either require explicit source cooperation (for example, by exporting data summaries), or build a relatively static source characterization (for example, by assigning a topic to the source). We present a system, called InfoBeacons, that takes a different approach: data and sources are left "as is," and a peer-to-peer network of beacons uses past query results to "guide" queries to sources, who do the actual query processing. This approach has several advantages, including requiring minimal changes to sources, tolerance of dynamism and heterogeneity, and the ability to scale to large numbers of sources. We present the architecture of the system, and discuss the advantages of our design. We then focus on how a beacon can choose good sources for a query despite the loose coupling of beacons to sources. Beacons cache responses to previous queries and adapt the cache to changes at the source. The cache is then used to select good sources for future queries. We discuss results from a detailed experimental study using our beacon prototype which demonstrates that our "loosely coupled" approach is effective; a beacon only has to contact sixty percent or less of the sources contacted by existing, tightly coupled approaches, while providing results of equivalent or better relevance to queries.

Adaptive resource sharing in a web services environment

Abstract: One effect of the push towards business process automation and IT consolidation is that low-level resources from multiple administrative domains are shared among multiple workloads and the middleware is called upon to bring about the integration while masking the details of sharing such resources. Web services and grid based technologies hold promise for developing such middleware. However, existing solutions do not extend well when resources to be shared belong to multiple administrative domains and when resource sharing is governed by local policies.In this paper, we describe an architecture for adaptive resource sharing among two types of workloads: (i) local resource specific workload and (ii) global web services based grid workload. Each resource can set its own policies regarding how the resource is to be shared. Our approach leverages both the grid and the web services based technologies and overcomes the limitations of existing solutions by providing an additional layer of middleware. This layer provides services for dynamic discovery and aggregation of resources, policy based and transparent management of resources, and dynamic workload scheduling using the concept of virtualized resources. We discuss some of the design choices we made and present performance results to show the effects of policy-based resource sharing on the throughput delivered to the grid workload.

Transparent information dissemination

Abstract: This paper describes Transparent Replication through Invalidation and Prefetching (TRIP), a self tuning data replication middleware system that enables transparent replication of large-scale information dissemination services. The TRIP middleware is a key building block for constructing information dissemination services, a class of services where updates occur at an origin server and reads occur at a number of replicas; examples information dissemination services include content distribution networks such as Akamai [1] and IBM's Sport and Event replication system [2]. Furthermore, the TRIP middleware can be used to build key parts of general applications that distribute content such as file systems, distributed databases, and publish-subscribe systems.Our data replication middleware supports transparent replication by providing two crucial properties: (1) sequential consistency to avoid introducing anomalous behavior to increasingly complex services and (2) self-tuning transmission of updates to maximize performance and availability given available system resources. Our analysis of simulations and our evaluation of a prototype support the hypothesis that it is feasible to provide transparent replication for dissemination services. For example, in simulations, our system's performance is a factor of three to four faster than a demand-based middleware system for a wide range of configurations.

Alternative edge-server architectures for enterprise JavaBeans applications

Abstract: Edge-server architectures are widely used to improve web-application performance for non-transactional data. However, their use with transactional data is complicated by the need to maintain a common database that is shared among different edge-servers. In this paper we examine the performance characteristics of alternative edge-server architectures for transactional Enterprise JavaBeans (EJBs) applications. In one architecture, a remote database is shared among a number of edge-servers; in another, edge-servers maintain cached copies of transactionally-consistent EJBs. Importantly, the caching function is transparent to applications that use it.

A content model for evaluating peer-to-peer searching techniques

Abstract: Simulation studies are frequently used to evaluate new peer-to-peer searching techniques as well as existing techniques on new applications. Unless these studies are accurate in their modeling of queries and documents, they may not reflect how search techniques will perform in real networks, leading to incorrect conclusions about which techniques are best. We describe how to model content so that simulations produce accurate results. We present a content model for peer-to-peer networks, which consists of a tripartite graph with edges connecting queries to the documents they match, and documents to the peers they are stored at. Our model also includes a set of statistics describing how often queries match the same documents, and how often similar documents are stored at the same peer. We can construct our tripartite content model by running queries over live data stored at real Internet nodes, and simulation results show that searching techniques do indeed perform differently in simulations using this "real" content model versus a randomly generated model. We then present an algorithm for using real content gathered from a small set of peers (say, 1,000) to generate a synthetic content model for large simulated networks (say, 10,000 nodes or more). Finally, we use a synthetic model generated from World Wide Web documents and queries to compare the performance of several search algorithms that have been reported in the literature.

A game theoretic approach for power aware middleware

Abstract: In this paper, we propose a dynamic game theoretic approach for choosing power optimization strategies for various components(e.g. cpu, network interface etc.) of a low-power device operating in a distributed environment. Specifically, we model the energy consumption problem as a dynamic non-cooperative game theoretic problem, where the various components of the device are modelled as the players in the game that simultaneously consume a common resource (device battery power). An analysis for the Nash and social optima of the game is presented. We then introduce an adaptive distributed power-aware middleware framework, called "Dynamo", that incorporates the game theoretic approach for determining optimal power optimization strategies. We simulate the distributed game environment for proxy-based video streaming to a mobile handheld device. Our performance results indicate that significant energy savings are achievable for the device when the energy usage of the individual components achieve a social optima than when the energy usage achieves the strategic Nash equilibria. The overall utility of the system is measured both in terms of energy gains and the quality of video playback. Our results indicate that the device lifetime was increased by almost 50%-90% when compared to the case where no power optimization strategies were used, and 30-40% over device lifetime when Nash equilibrium is achieved; the overall utility of system for both types of equilibria were similar (utilities differ by ≤ .5%), indicating that the Nash equilibrium strategies tend to overuse the battery energy consumption.

Middleware and web services for the collaborative information portal of NASA's Mars exploration rovers mission

Abstract: We describe the design and deployment of the middleware for the Collaborative Information Portal (CIP), a mission critical J2EE application developed for NASA's 2003 Mars Exploration Rover mission. CIP enabled mission personnel to access data and images sent back from Mars, staff and event schedules, broadcast messages and clocks displaying various Earth and Mars time zones. We developed the CIP middleware in less than two years time using cutting-edge technologies, including EJBs, servlets, JDBC, JNDI and JMS. The middleware was designed and implemented as a collection of independent, hot-deployable web services, providing secure access to back end file systems and databases. This service-oriented approach to developing an integrated system is an example of cutting edge middleware design. Throughout the middleware we enabled crosscutting capabilities such as runtime service configuration, security, logging and remote monitoring. This paper presents our approach to mitigating the challenges we faced, concluding with a short review of the lessons we learned from this project and noting some of the things we would do differently and why.