Showing papers on "Consistency (database systems) published in 2003"

Automatic detection and repair of errors in data structures

Abstract: We present a system that accepts a specification of key data structure consistency constraints, then dynamically detects and repairs violations of these constraints, enabling the program to continue to execute productively even in the face of otherwise crippling errors. Our experience using our system indicates that the specifications are relatively easy to develop once one understands the data structures. Furthermore, for our set of benchmark applications, our system can effectively repair inconsistent data structures and enable the program to continue to operate successfully.

Answer sets for consistent query answering in inconsistent databases

Abstract: A relational database is inconsistent if it does not satisfy a given set of integrity constraints. Nevertheless, it is likely that most of the data in it is consistent with the constraints. In this paper we apply logic programming based on answer sets to the problem of retrieving consistent information from a possibly inconsistent database. Since consistent information persists from the original database to every of its minimal repairs, the approach is based on a specification of database repairs using disjunctive logic programs with exceptions, whose answer set semantics can be represented and computed by systems that implement stable model semantics. These programs allow us to declare persistence by default of data from the original instance to the repairs; and changes to restore consistency, by exceptions. We concentrate mainly on logic programs for binary integrity constraints, among which we find most of the integrity constraints found in practice.

High-Level Data Races

Abstract: Data races are a common problem in concurrent and multi-threaded programming. They are hard to detect without proper tool support. Despite the successful application of these tools, experience shows that the notion of data race is not powerful enough to capture certain types of inconsistencies occurring in practice. In this paper we investigate data races on a higher abstraction layer. This enables us to detect inconsistent uses of shared variables, even if no classical race condition occurs. For example, a data structure representing a coordinate pair may have to be treated atomically. By lifting the meaning of a data race to a higher level, such problems can now be covered. The paper defines the concepts view and view consistency to give a notation for this novel kind of property. It describes what kinds of errors can be detected with this new definition, and where its limitations are. It also gives a formal guideline for using data structures in a multi-threading environment.

Impact analysis and change management of UML models

Abstract: The use of Unified Modeling Language (UML) analysis/design models on large projects leads to a large number of interdependent UML diagrams. As software systems evolve, those diagrams undergo changes to, for instance, correct errors or address changes in the requirements. Those changes can in turn lead to subsequent changes to other elements in the UML diagrams. Impact analysis is then defined as the process of identifying the potential consequences (side-effects) of a change, and estimating what needs to be modified to accomplish a change. In this article, we propose a UML model-based approach to impact analysis that can be applied before any implementation of the changes, thus allowing an early decision-making and change planning process. We first verify that the UML diagrams are consistent (consistency check). Then changes between two different versions of a UML model are identified according to a change taxonomy, and model elements that are directly or indirectly impacted by those changes (i.e., may undergo changes) are determined using formally defined impact analysis rules (written with Object Constraint Language). A measure of distance between a changed element and potentially impacted elements is also proposed to prioritize the results of impact analysis according to their likelihood of occurrence. We also present a prototype tool that provides automated support for our impact analysis strategy, that we then apply on a case study to validate both the implementation and methodology.

Flexible consistency checking

Abstract: The problem of managing the consistency of heterogeneous, distributed software engineering documents is central to the development of large and complex systems. We show how this problem can be addressed using xlinkit, a lightweight framework for consistency checking that leverages standard Internet technologies. xlinkit provides flexibility, strong diagnostics, and support for distribution and document heterogeneity. We use xlinkit in a comprehensive case study that demonstrates how design, implementation and deployment information of an Enterprise JavaBeans system can be checked for consistency, and rechecked incrementally when changes are made.

Modeling and validation of service-oriented architectures: application vs. style

Abstract: Most applications developed today rely on a given middleware platform which governs the interaction between components, the access to resources, etc. To decide, which platform is suitable for a given application (or more generally, to understand the interaction between application and platform), we propose UML models of both the architectural style of the platform and the application scenario. Based on a formal interpretation of these as graphs and graph transformation systems, we are able to validate the consistency between platform and application.

Formal methods for the validation of automotive product configuration data

Abstract: In the automotive industry, the compilation and maintenance of correct product configuration data is a complex task. Our work shows how formal methods can be applied to the validation of such business critical data. Our consistency support tool BIS works on an existing database of Boolean constraints expressing valid configurations and their transformation into manufacturable products. Using a specially modified satisfiability checker with an explanation component, BIS can detect inconsistencies in the constraints set and thus help increase the quality of the product data. BIS also supports manufacturing decisions by calculating the implications of product or production environment changes on the set of required parts. In this paper, we give a comprehensive account of BIS: the formalization of the business processes underlying its construction, the modifications of satisfiability-checking technology we found necessary in this context, and the software technology used to package the product as a client–server information system.

On the interplay between consistency, completeness, and correctness in requirements evolution

Abstract: The initial expression of requirements for a computer-based system is often informal and possibly vague. Requirements engineers need to examine this often incomplete and inconsistent brief expression of needs. Based on the available knowledge and expertise, assumptions are made and conclusions are deduced to transform this \rough sketch" into more complete, consistent, and hence correct requirements. This paper addresses the question of how to characterize these properties in an evolutionary framework, and what relationships link these properties to a customer’s view of correctness. Moreover, we describe in rigorous terms the dieren t kinds of validation checks that must be performed on dieren t parts of a requirements specication in order to ensure that errors (i.e., cases of inconsistency and incompleteness) are detected and marked as such, leading to better quality requirements.

A Dynamic Programming Approach for Consistency and Propagation for Knapsack Constraints

Abstract: Knapsack constraints are a key modeling structure in constraint programming. These constraints are normally handled with simple bounding arguments. We propose a dynamic programming structure to represent these constraints. With this structure, we are able to achieve hyper-arc consistency, to determine infeasibility before all variables are set, to generate all solutions quickly, and to provide incrementality by updating the structure after domain reduction. Testing on a difficult set of multiple knapsack instances shows significant reduction in branching.

Application specific data replication for edge services

Abstract: The emerging edge services architecture promises to improve the availability and performance of web services by replicating servers at geographically distributed sites. A key challenge in such systems is data replication and consistency so that edge server code can manipulate shared data without incurring the availability and performance penalties that would be incurred by accessing a traditional centralized database. This paper explores using a distributed object architecture to build an edge service system for an e-commerce application, an online bookstore represented by the TPC-W benchmark. We take advantage of application specific semantics to design distributed objects to manage a specific subset of shared information using simple and effective consistency models. Our experimental results show that by slightly relaxing consistency within individual distributed objects, we can build an edge service system that is highly available and efficient. For example, in one experiment we find that our object-based edge server system provides a factor of five improvement in response time over a traditional centralized cluster architecture and a factor of nine improvement over an edge service system that distributes code but retains a centralized database.

System and method for generating residential loan documents from multiple and diverse databases

Abstract: The present invention provides a system for preparing loan documents that uses multiple and diverse databases. The present invention uses a first database to store data and procedures for processing data provided by a mortgage originator. A second database stores data and procedures from an investor for processing the provided data. A comparison engine compares the provided data and identifies discrepancies between the originator and investor data and allows those discrepancies to be viewed and reconciled. A documentation preparation engine receives additional information from the users to prepare loan documents with the reconciled data and any additional information. A compliance engine audits the reconciled data and additional information to ensure consistency with procedures and compliance requirements and allows noncompliant data to be identified and reconciled. Documents from the forms library are then populated with the information and delivered by a documentation delivery engine to the end user.

Fast stereo matching using reliability-based dynamic programming and consistency constraints

Abstract: A method for solving binocular and multiview stereo matching problems is presented here. A weak consistency constraint is proposed, which expresses the visibility constraint in the image space. It can be proved that the weak consistency constraint holds for scenes that can be represented by a set of 3D points. As well, also proposed is a new reliability measure for dynamic programming techniques, which evaluates the reliability of a given match. A novel reliability-based dynamic programming algorithm is derived accordingly, which can selectively assign disparity values to pixels when the reliabilities of the corresponding matches exceed a given threshold. Consistency constraints and the new reliability-based dynamic programming algorithm can be combined in an iterative approach. The experimental results show that the iterative approach can produce dense (60-90%) and reliable (total error rate of 0.1-1.1%) matching for binocular stereo datasets. It can also generate promising disparity maps for trinocular and multiview stereo datasets.

System and method for achieving deferred invalidation consistency

Abstract: In a system having a plurality of caches, a method for maintaining cached objects includes storing an object in a plurality of caches. In response to a request to update the object, a future invalidation time is determined when the object should be invalidated in caches currently storing the object. Updating of the object is delayed until the invalidation time has passed.

Consistency maintenance in peer-to-peer file sharing networks

Abstract: While the current generation of peer-to-peer networks share predominantly static files, future peer-to-peer networks will support sharing of files that are modified frequently by their users. We present techniques to maintain temporal consistency of replicated files in a peer-to-peer network. We consider the Gnutella P2P network and present techniques for maintaining consistency in Gnutella even when peers containing replicated files dynamically join and leave the network. An experimental evaluation of our techniques shows that: (i) a hybrid approach based on push and pull achieves high fidelity in highly dynamic P2P networks and (ii) the run-time overheads of our techniques are small, making them a practical choice for P2P networks.

Systems and methods for caching and invalidating database results and derived objects

Abstract: The present invention relates to systems and methods for saving results generated from database queries such as raw data, objects, queryable data sets, full or partial web responses, in memory for current and subsequent utilization and invaliding the saved results when they become inconsistent to mitigate employing inconsistent results. The saved results can be employed by one or more components and are typically utilized when a subsequent query would return substantially similar results. Thus, the system and methods mitigate performing substantially redundant queries that can reduce performance and consume resources. When a database change occurs that affect the consistency of the saved results and/or expiration period lapses, an invalidation message can be transmitted, wherein the message is employed to invalidate the saved results. Thus, the systems and methods mitigate employing inconsistent saved results. In addition, automatic re-querying techniques can be employed to automatically refresh inconsistent results to obtain consistent results.

Checking Consistency in UML Diagrams: Classes and State Machines

Abstract: One of the main advantages of the UML is its possibility to model different views on a system using a range of diagram types The various diagrams can be used to specify different aspects, and their combination makes up the complete system description This does, however, always pose the question of consistency: it may very well be the case that the designer has specified contradictory requirements which can never be fulfilled together

GP-evolved Technical Trading Rules Can Outperform Buy and Hold

Abstract: This paper presents a number of experiments in which GP-evolved technical trading rules outperform a buy-and-hold strategy on the S&P500, even taking into account transaction costs. Several methodology changes from previous work are discussed and tested. These include a complexity-penalizing factor, a fitness function that considers consistency of performance, and coevolution of a separate buy and sell rule.

A Plug-In for Flexible and Incremental Consistency Management

Abstract: The problem of inconsistency detection and management is central to the development of large and complex software systems. Although sufficient support for model consistency is a crucial prerequisite for the successful and effective application of CASE tools, the current tool support is rather limited. In this paper we present a flexible and incremental consistency management realized in the Open Source UML CASE tool Fujaba. The consistency management is highly configurable and can be adapted individually to user, project or domain specific demands. For the specification of syntactical consistency rules we provide a built-in formalism based on graph grammars.

The importance of aggregation

Abstract: In this paper, we define aggregation as the ability to summarize information. In the area of sensor networks [16.2] it is also referred to as data fusion. It is the basis for scalability for many, if not all, large networking services. For example, address aggregation allows Internet routing to scale.Without it, routing tables would need a separate entry for each Internet address. Besides a problem of memory size, populating the tables would be all but impossible. DNS also makes extensive use of aggregation, allowing domain name to attribute mappings to be resolved in a small number of steps. Many basic distributed paradigms and consistency mechanisms are based on aggregation. For example, synchronization based on voting requires votes to be counted. Aggregation is a standard service in databases. Using SQL queries, users can explicitly aggregate data in one or more tables in a variety of ways.

What is Input/Output Logic?

Abstract: We explain the raison d’etre and basic ideas of input/output logic, sketching the central elements with pointers to other publications for detailed developments. The motivation comes from the logic of norms. Unconstrained input/output operations are straightforward to define, with relatively simple behaviour, but ignore the subtleties of contrary-to-duty norms. To deal with these more sensitively, we constrain input/output operations by means of consistency conditions, expressed via the concept of an outfamily. However, this is a more complex affair, with difficult choices between alternative options.

An adaptive quality of service aware middleware for replicated services

Abstract: A dependable middleware should be able to adaptively share the distributed resources it manages in order to meet diverse application requirements, even when the quality of service (QoS) is degraded due to uncertain variations in load and unanticipated failures. We have addressed this issue in the context of a dependable middleware that adaptively manages replicated servers to deliver a timely and consistent response to time-sensitive client applications. These applications have specific temporal and consistency requirements, and can tolerate a certain degree of relaxed consistency in exchange for better response time. We propose a flexible QoS model that allows clients to specify their timeliness and consistency constraints. We also propose an adaptive framework that dynamically selects replicas to service a client's request based on the prediction made by probabilistic models. These models use the feedback from online performance monitoring of the replicas to provide probabilistic guarantees for meeting a client's QoS specification. The experimental results we have obtained demonstrate the role of feedback and the efficacy of simple analytical models for adaptively sharing the available replicas among the users under different workload scenarios.

Workshop on "Consistency Problems in UML-based Software Development II"

Abstract: Workshop materials of the Second Workshop on Consistency Problems in UML-based Software Development. The workshop is part of the Sixth International Conference on The Unified Modeling Language > 2003

Information processing method and apparatus

Abstract: In an information processing method for maintaining, in a system in which each of a plurality of processes connected via a network holds and uses shared data to be shared by the processes, consistency of shared data held by the respective processes, when a manipulation request for the shared data is generated, an event indicating that manipulation request is output onto the network An event as a reply to the event output onto the network is received from the network A manipulation for the shared data is executed in accordance with the received event In this way, the manipulation execution timings for shared data to be shared by a plurality of processes can be accurately matched

Trading replication consistency for performance and availability: an adaptive approach

Abstract: Replication system is one of the most fundamental building blocks of wide-area applications. Due to the inevitable dependencies on wide-area communication, trade-off between performance, availability and replication consistency is often a necessity. While a number of proposals have been made to provide a tunable consistency bound between strong and weak extremes, many of them rely on a statically specified enforcement across replicas. This approach, while easy to implement, neglects the dynamic contexts within which replicas are operating, delivering sub-optimal performance and/or system availability. In this paper we analyze the problem of optimal performance/availability for a given consistency level under heterogeneous workload and network condition. We prove several optimization rules for different goals. Based on these results, we developed an adaptive update window protocol in which consistency enforcement across replicas is self-tuned to achieve optimal performance/availability. A prototype system, FRACS, is built and evaluated in this paper. The experiment results demonstrate significant advantages of adaptation over static approach for a variety of workloads.

Multi-writer Consistency Conditions for Shared Memory Objects

Abstract: Regularity is a shared memory consistency condition that has received considerable attention, notably in connection with quorum-based shared memory. Lamport’s original definition of regularity assumed a single-writer model, however, and is not well-defined when each shared variable may have multiple writers. In this paper, we address this need by formally extending the notion of regularity to a multi-writer model. We give three possible definitions of regularity in the presence of multiple writers. We then present a quorum-based algorithm to implement each of the three definitions and prove them correct. We study the relationships between these definitions and a number of other well-known consistency conditions, and give a partial order describing the relative strengths of these consistency conditions. Finally, we provide a practical context for our results by studying the correctness of two well-known algorithms for mutual exclusion under each of our proposed consistency conditions.

Solap: a new type of user interface to support spatio-temporal multidimensional data exploration and analysis

Abstract: It is well known that transactional and analysis systems each require a different database structure. In general, the database structure of transactional systems is optimized for consistency and efficient updates while the database structure of analysis systems is optimized for complex query performance. Non-spatial data are reorganized in data warehouses in order to support analysis and decision-making. In the same way, spatial data need to be stored in spatial data warehouses to support spatio-temporal decision-making. However, the actual client tools used to exploit the data warehouse are not well adapted to fully exploit the spatial data warehouse. New client tools are then required to take full advantage of the geometric component of the spatial data. GIS are potential candidates but despite interesting spatiotemporal analysis capabilities, it is recognized that actual GIS systems per se are not optimally designed to be used to support decision applications and that alternative solutions should be used (Bedard et al, 2001). Among them, the Spatial OLAP (SOLAP) tools offer promising possibilities. A SOLAP tool can be defined as “a visual platform built especially to support rapid and easy spatio-temporal analysis and exploration of data following a multidimensional approach comprised of aggregation levels available in cartographic displays as well as in tabular and diagram displays” (Bedard, 1997). SOLAP tools form a new family of user interfaces and are meant to be client applications sitting on top of a multi-scale spatial data warehouse. They are based on the multidimensional paradigm. This document presents the concepts of SOLAP, the characteristics of this new type of user interface, and examples related to a few of the many possible application domains. A live demonstration of a SOLAP tool will complete this document.

An analysis of structural validity in entity-relationship modeling

Abstract: We explore the criteria that contribute to the structural validity of modeling structures within the entity-relationship (ER) diagram. Our approach examines cardinality constraints in conjunction with the degree of the relationship to address constraint consistency, state compliance, and role uniqueness issues to derive a complete and comprehensive set of decision rules. Unlike typical other analyses that use only maximum cardinality constraints, we have used both maximum and minimum cardinality constraints in defining the properties and their structural validity criteria yielding a complete analysis of the structural validity of recursive, binary, and ternary relationship types. Our study evaluates these relationships as part of the overall diagram and our rules address these relationships as they coexist in a path structure within the model. The contribution of this paper is to provide a comprehensive set of decision rules to determine the structural validity of any ERD containing recursive, binary, and ternary relationships. These decision rules can be readily applied to real world data models regardless of their complexity. The rules can easily be incorporated into the database modeling and designing process, or extended into case tool implementations.

Consistency techniques for interprocedural test data generation

Abstract: This paper presents a novel approach for automated test data generation of imperative programs containing integer, boolean and/or float variables. It extends our previous work to programs with procedure calls and arrays. A test program (with procedure calls) is represented by an Interprocedural Control Flow Graph (ICFG). The classical testing criteria (statement, branch, and path coverage), widely used in unit testing, are extended to the ICFG. For path coverage, the specified path is transformed into a path constraint. Our previous consistency techniques, the core idea behind the solving of path constraints, have been extended to handle procedural calls and operations with arrays. For statement (and branch) coverage, paths reaching the specified node or branch are dynamically constructed. The search for suitable paths is guided by the interprocedural control dependences of the program. The search is also pruned by a new specialized consistency filter. Finally, test data are generated by the application of the proposed path coverage algorithm. A prototype has been implemented. Experiments show the feasibility of the approach.