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

Leases: an efficient fault-tolerant mechanism for distributed file cache consistency

Abstract: Caching introduces the overhead and complexity of ensuring consistency, reducing some of its performance benefits. In a distributed system, caching must deal with the additional complications of communication and host failures.Leases are proposed as a time-based mechanism that provides efficient consistent access to cached data in distributed systems. Non-Byzantine failures affect performance, not correctness, with their effect minimized by short leases. An analytic model and an evaluation for file access in the V system show that leases of short duration provide good performance. The impact of leases on performance grows more significant in systems of larger scale and higher processor performance.

Automatic verification of database transaction safety

Abstract: Maintaining the integrity of databases is one of the promises of database management systems. This includes assuring that integrity constraints are invariants of database transactions. This is very difficult to accomplish efficiently in the presence of complex constraints and large amounts of data. One way to minimize the amount of processing required to maintain database integrity over transaction processing is to prove at compile-time that transactions cannot, if run atomically, disobey integrity constraints. We report on a system that performs such verification for a robust set of constraint and transaction classes. The system accepts database schemas written in a more or less traditional style and accepts programs in a high-level programming language. Automatic verification fast enough to be effective on current workstation hardware is performed.

Performance characterization of quorum-consensus algorithms for replicated data

Abstract: The authors develop a model and define performance measures for a replicated data system that makes use of a quorum-consensus algorithm to maintain consistency. They consider two measures: the proportion of successfully completed transactions in systems where a transaction aborts if data is not available, and the mean response time in systems where a transaction waits until data becomes available. Based on the model, the authors show that for some quorum assignment there is an optimal degree of replication beyond which performance degrades. There exist other quorum assignments which have no optimal degree of replication. The authors also derive optimal read and write quorums which maximize the proportion of successful transactions. >

Translation lookaside buffer consistency: a software approach

Abstract: We discuss the translation lookaside buffer (TLB) consistency problem for multiprocessors, and introduce the Mach shootdown algorithm for maintaining TLB consistency in software. This algorithm has been implemented on several multiprocessors, and is in regular production use. Performance evaluations establish the basic costs of the algorithm and show that it has minimal impact on application performance. As a result, TLB consistency does not pose an insurmountable obstacle to multiprocessors with several hundred processors. We also discuss hardware support options for TLB consistency ranging from a minor interrupt structure modification to complete hardware implementations. Features are identified in current hardware that compound the TLB consistency problem; removal or correction of these features can simplify and/or reduce the overhead of maintaining TLB consistency in software.

A filtering process for general constraint-satisfaction problems: achieving pairwise-consistency using an associated binary representation

Abstract: Considers the use of a partial consistency, issuing from relational database theory, within the constraint-satisfaction problems (CSPs) framework, i.e., pairwise consistency. This partial consistency concerns general CSPs (i.e., CSPs the constraints of which may involve more than two variables). The authors provide a polynomial algorithm for achieving this consistency; then they extend the class of polynomially solvable CSPs. This algorithm is based on a minimal binary representation of a general CSP. >

Consistency issues in real-time database systems

Abstract: A consistency model is presented of real-time database systems that distinguishes the external data consistency from the internal data consistency as maintained by traditional systems, to provide a transaction schedule to meet deadlines. External consistency requires that the data used by a transaction reflect the current physical environment; this is in contrast to internal consistency, which presents a view consistent with the predefined constraints of the database. It is suggested that external consistency is preferable to internal consistency for many transactions. Operationally consistent schedules are defined that emphasize the operational effect of databases to the external world. A protocol that ensures the external consistency of transactions is presented. >

Availability and consistency tradeoffs in the Echo distributed file system

Abstract: The use of server replication to increase the availability of remote servers in a system of workstations is discussed. Tradeoffs between consistency of replication and caching versus availability are considered for the Echo distributed file system which uses two different replication techniques, one at the upper levels of the hierarchical name space, the name service, and another at the lower levels of the name space, the file volume service. The two replication techniques provide different guarantees of consistency between their replicas and, therefore, different levels of availability. Echo also caches data from the name service and file volume service in client machines (e.g. workstations), with the cache for each service having its own cache consistency guarantee that mimics the guarantee on the consistency of the replicas for that service. The replication and caching consistency guarantees provided by each service are appropriate for its intended use. >

Temporal constraint networks

Abstract: This paper extends network-based methods of constraint satisfaction to include continuous variables, thus providing a framework for processing temporal constraints. In this framework, called temporal constraint satisfaction problem (TCSP), variables represent time points and temporal information is represented by a set of unary and binary constraints, each specifying a set of permitted intervals. The unique feature of this framework lies in permitting the processing of metric information, namely, assessments of time differences between events. We present algorithms for performing the following reasoning tasks: finding all feasible times that a given event can occur, finding all possible relationships between two given events, and generating one or more scenarios consistent with the information provided. We distinguish between simple temporal problems (STPs) and general temporal problems, the former admitting at most one interval constraint on any pair of time points. We show that the STP, which subsumes the major part of Vilain and Kautz's point algebra, can be solved in polynomial time. For general TCSPs, we present a decomposition scheme that performs the three reasoning tasks considered, and introduce a variety of techniques for improving its efficiency. We also study the applicability of path consistency algorithms as preprocessing of temporal problems, demonstrate their termination and bound their complexities.

Negotiating data access in federated database systems

Abstract: A protocol is presented for negotiating access to data in a federated database. This protocol deals with several important aspects of data sharing in an environment where databases belonging to different organizations coexist and cooperate. It is based on the concept of quasicopies. These are cached values that are allowed to deviate from the central value in a controlled fashion. The degree of consistency of a quasicopy is established by the entity where the quasicopy is to reside. Two techniques are presented that can be used for numerical data and for copies that rely on version numbers. It is believed that these two ideas encompass many of the interesting cases in practice. However, it is also possible to fine tune the estimation of this function once the exact semantics of the data involved are known. >

Low-synchronization translation lookaside buffer consistency in large-scale shared-memory multiprocessors

Abstract: Operating systems for most current shared-memory multiprocessors must maintain translation lookaside buffer (TLB) consistency across processors. A processor that changes a shared page table must flush outdated mapping information from its own TLB, and it must force the other processors using the page table to do so as well. Published algorithms for maintaining TLB consistency on some popular commercial multiprocessors incur excessively high synchronization costs. We present an efficient TLB consistency algorithm that can be implemented on multiprocessors that include a small set of reasonable architectural features. This algorithm has been incorporated in a version of the MACH operating system developed for the IBM Research Parallel Processor Prototype (RP3).

A Cache Consistency Protocol For Multiprocessors With Multistage Networks

Abstract: A hardware based cache consistency protocol for multipro cessors with multistage networks is proposed. Consistency traffic is restricted to the set of caches which have a copy of a shared block. State information is distributed to the caches and the memory modules need not be consulted for consistency actions. The protocol provides two operating modes: distributed write and global read. Distribution of writes calls for efficient . . . mulficast methods. Communication cost for multicasting is analyzed and a novel scheme is proposed. Finally, communication cost for the protocol is compared to other protocols. The two-mode approach limits the upper bound for the communication cost to a value considerably lower than that for other protocols.

Leases: an efficient fault-tolerant mechanism for distributed file cache consistency

Abstract: Caching introduces the overhead and complexity of ensuring consistency, reducing some of its performance benefits In a distributed system, caching must deal with the additional complications of co

A dynamic voting scheme in distributed systems

Abstract: A dynamic weighted voting scheme for consistency and recovery control of replicated files in distributed systems is presented. The purpose of a replicated file is to improve the availability of a logical file in the presence of site failures and network partitions. The accessible physical copies of a replicated file will be mutually consistent and behave as a single copy. The recovery scheme requires no manual intervention. The control scheme tolerates any number of site failures and network partitions as well as repairs. Correctness results are given. >

Automatic runtime consistency checking and debugging of formally specified programs

Abstract: This thesis studies an approach to automate the process of deciding whether a program is performing correctly, and if not, to discover the probable cause of the problem. It assumes that the intended behavior of the program is specified in some formal, high-level specification language. It studies how one can check automatically at runtime whether the program is running consistently with its specification, and if not, how inconsistencies can be automatically detected and diagnosed. A methodology of using this checking methodology for debugging formally specified programs is then presented. The consistency checking methodology depends on the particular specification language constructs used. In this thesis, two categories of constructs are studied: (1) generalized assertions and (2) algebraic specifications. Generalized assertions contain boolean expressions that must be satisfied within a specified region in the underlying program. Checking functions are generated which test for the truth of these boolean expressions. Diagnostic messages are given and a debugger is invoked if there is a violation. Checking functions are called from locations in the program where the specification may have changed value. For the purpose of this thesis, algebraic specifications are considered to be equations whose terms comprise abstract data type operations. Algebraic specification checking involves monitoring the execution of the abstract data type operations. Based on this monitoring and the algebraic specifications, a theorem prover generates invariants that the program must satisfy. If the program does not satisfy these invariants, diagnostic messages are given and a debugger is invoked. The theorem prover has to be specialized so that it operates efficiently in the context of algebraic specification checking. Methodologies to achieve this using incremental techniques are presented in this thesis. Based on these ideas, a working system has been built for automatic runtime consistency checking of Ada programs with specifications written in Anna. Experiments with this system has led to the development of a methodology of debugging programs based on formal specifications.

A well structured parallel file system for PM

Abstract: PM is a new object-oriented methodology which allows a more structured approach to the specification and implementation of software for distributed and multiprocessor architectures. In order to evaluate the correctness and efficiency of the PM prototype implementation, it has been decided to build a highly parallel distributed file system as a first application.This paper outlines the design of this file system. Starting with the proposal of an overall structure for the system, we will then detail each type of object it will be made of and propose solutions in response to the classical problems encountered in the area of file systems, provision of a transaction mechanism and guarantee of the consistency of the users' data.

An approach to verifying completeness and consistency in a rule-expert system

Abstract: We describe a program for verifying that a set of rules in an expert system comprehensively spans the knowledge of a specialized domain. The program has been devised and tested within the context of the ONCOCIN System, a rule-based consultant for clinical oncology. The stylized format of ONCOCIN''s rules has allowed the automatic detection of a number of common errors as the knowledge base has been developed. This capability suggests a general mechanism for correcting many problems with knowledge base completeness and consistency before they can cause performance errors.

Inconsistency of production systems

Abstract: Production systems are widely used for knowledge representation in expert systems. Using production systems it is possible to specify inconsistent knowledge, but in the case of inconsistency the world kept in mind when establishing the knowledge is most probably not formalized. Another reason for the relevance of consistency results from a logical point of view because any formula can be derived from an inconsistent theory. Thus, we consider special production systems motivated by the knowledge representation form used in various expert system shells. We define inconsistency for this kind of production systems. Afterwards we give a logical description such that inconsistent production systems are represented by unsatisfiable propositional calculus formulas and vice versa. We present algorithms deciding inconsistency of production systems and analyze their complexity. We also consider problems connected with inconsistency arising when using external databases or allowing user inputs. Finally, we investigate the complexity of production systems with negation proving that these production systems are more expressive than those without negation. Our considerations should be regarded as a step towards an exact formal definition of inconsistency of production systems and its complexity.

Chapter on Distributed Computing

Abstract: : Rigorous analysis starts with a precise model of a distributed system; the most popular models, differing in how they represent interprocess communication, are message passing, shared variables, and synchronous communication. The properties satisfied by an algorithm must be precisely stated and carefully proved; the most successful approach is based on assertional reasoning. Algorithms for solving particular problems in a distributed system can then be designed and analyzed. Typical of the problems that have been addressed are: concurrently accessing shared data, achieving consensus, analyzing network topology, obtaining consistent global information, and controlling database transactions.

Escort: an environment for specifying communication requirements

Abstract: A prototype specification support system, Escort, is described that incorporates novel validation, verification, and simplification methods for telecommunications software specifications. Unix was adapted as the operating system for Escort, and many of Escort's tools were designed and implemented by making full use of the Unix facilities. Escort identifies three kinds of specification errors: errors in the grammar of the specification language, called syntax errors; those that degrade consistency and completeness, called logical errors; and those that degrade correctness, called semantic errors. It detects these errors using syntax analysis, validation, and verification, respectively. >

Read-only transactions in partitioned replicated databases

Abstract: Environments where read-only transactions predominate update transactions are considered. The notion of a group in replicated databases, the recognition of which maximizes the data availability for read-only transactions in error-prone environments, is developed. It is shown that the group identification problem is NP-complete. Replica control algorithms that attempt to approximately determine groups are presented. In one algorithm, groups are determined dynamically; in the other techniques, groups are predefined. It is shown formally that both approaches yield algorithms that preserve the consistency of the database. In the environments considered, the approaches presented are shown to yield significant improvements over other fault-tolerant replica control algorithms. >

Techniques for data and rule validation in knowledge based systems

Abstract: A framework is proposed for the validation of data and rules in knowledge-based systems. This work involves three major tasks: (1) validation of data; (2) validation of rules; and (3) interaction between data and rule validation. These tasks are conducted on a rule set that specifies the dependencies of rule variables. Data validation is performed by using the enforcement of constraint rules. Constraint rules are also propagated for the overall database consistency. A scheme for rule validation is sketched. The completeness and consistency of rules are verified by a theorem-proving method. It is concluded that production rules should be restricted by constraint rules, whereas constraint rules can correct the inconsistency of data by reasoning production rules. >

Some computational properties of a model for electronic documents

Abstract: SUMMARY Differing types of documents exhibit varying structures. These may arise, at one level, because of the material comprising the text ‐ thus textbooks will be organized differently from research papers ‐ and at a lower level as a result of the layout conventions by which the text is formatted. These structuring regimes may be seen as defining a set of constraints which a document within a specific class must satisfy. In this paper we examine the model recently proposed in Reference [1] which is used for representing and modifying electronic documents. This employs simple graph grammars as a means of translating changes in the document structure into modifications to the computer representation. The aim of this approach is to provide computer support which will allow the appropriate structural conventions to be preserved while the document is being edited. We consider the following problem with this method: given a set of ‘constraints’ which the document must satisfy and a collection of rules prescribing how the document representation may be modified, how does one prove that only documents which obey the constraints can be generated by repeated applications of the rules? We describe one way in which this question can be more precisely formulated and call this the consistency checking problem. It is shown that, in general, this problem cannot be solved. We then outline how, for practical applications, the consistency checking problem may be solved for certain special cases.

Structure design of distributed systems using interpreted Petri nets

Abstract: An approach is presented to internal structure design of distributed systems in the field of process control. Starting from an IPN (interpreted Petri net) specifying the external behavior of a system, the approach (based on a set of decomposition rules) allows a systematic construction of structure specification, thus making unnecessary the consistency verification usually employed in top-down design methods. It is shown that the decomposition rules presented allow systematic construction of the internal structure of distributed systems. These rules free the designer from specifying intermodule cooperation and from verifying consistency between the external behavior and the internal structure specification. >

Hierarchical and functional architecture for control systems

Abstract: An approach to automated system specification is described. It is shown that the introduction of general concepts, including typical constraints of automated systems (e.g. operating modes, topology, and coordination), helps the designer to understand the user requirements, giving a global view of them. The refinement of this first model, with the use of an elementary notion, allows the designer to organize user functions and information precisely and helps the verification of completeness and consistency. To build up this model, the use of criteria adapted to automated system constraints is the key to a successful and well-suited specification model. The internal specification of an elementary notion in terms of generic functions and information introduces a way of specification validation and generalizes the proposed model, which is then adapted to any type of system. >

DB-Prolog: a database programming environment for CACSD

Abstract: DB-Prolog, a database programming language based on the extension of Prolog, is introduced for the purpose of computer-aided control systems design. Structural properties of data can be modeled using the classification generalization, and aggregation abstractions, while the dynamic behaviors can be captured in derivation rules. Furthermore, all data items may persist in an external database and be manipulated directly in the underlying language. A system of integrity constraint definition and maintenance is incorporated to keep the database consistent at all times. The data modeling concept is presented, and the syntax and semantics for various extensions are given. Other aspects, such as built-in operators, the strategy for maintaining consistency, and communication with an external numerical package Pro-Matlab, are mentioned briefly. An example is presented to demonstrate some of the potential benefits of DB-Prolog as an environment for CACSD. >

On reliability modelling of fault-tolerant distributed systems

Abstract: The problem of predicting the reliability of a distributed system based on the principles of Byzantine agreement is addressed. The system is considered inoperable or failed if Byzantine agreement cannot be guaranteed. The reliability models depend on a unified model of interactive consistency, which is based on a unique fault taxonomy appropriate for distributed systems. The unified model takes advantage of the fact that some faults may not be of an arbitrary nature, while still allowing for the fact that some faults may be arbitrary. A closed-form expression for the reliability and the mean time to failure of systems base on the unified model is derived. Each processor is allowed to have multiple failure modes, and the contribution of the interactive consistency algorithm is explicitly taken into account. The practical value of this unified model in designing ultrareliable systems is demonstrated by several examples. >

Recovery in main memory database systems for engineering design applications

Abstract: An engineering design database organizes the descriptions of complicated artefacts and requires high performance. The availability of large, relatively inexpensive main memories would enable the advent of high-performance engineering design databases that have all the data in main memory. The challenge in the design of such databases is to provide fast transaction processing by different access methods and to provide a rapid restart after a failure, ensuring that transactions are atomic and durable in spite of main memory's volatility. A recovery scheme for high-performance databases with large main memory is presented. It achieves noninterference and a fast restart through incremental checkpointing and log compression.