1,533 research outputs found
Management of concurrency in a reliable object-oriented computing system
PhD ThesisModern computing systems support concurrency as a means of increasing
the performance of the system. However, the potential for increased performance
is not without its problems. For example, lost updates and inconsistent retrieval
are but two of the possible consequences of unconstrained concurrency. Many
concurrency control techniques have been designed to combat these problems;
this thesis considers the applicability of some of these techniques in the context of
a reliable object-oriented system supporting atomic actions.
The object-oriented programming paradigm is one approach to handling the
inherent complexity of modern computer programs. By modeling entities from
the real world as objects which have well-defined interfaces, the interactions in
the system can be carefully controlled. By structuring sequences of such
interactions as atomic actions, then the consistency of the system is assured.
Objects are encapsulated entities such that their internal representation is not
externally visible. This thesis postulates that this encapsulation should also
include the capability for an object to be responsible for its own concurrency
control.
Given this latter assumption, this thesis explores the means by which the
property of type-inheritance possessed by object-oriented languages can be
exploited to allow programmers to explicitly control the level of concurrency an
object supports. In particular, a object-oriented concurrency controller based
upon the technique of two-phase locking is described and implemented using
type-inheritance. The thesis also shows how this inheritance-based approach is
highly flexible such that the basic concurrency control capabilities can be adopted
unchanged or overridden with more type-specific concurrency control if requiredUK Science and Engineering Research Council,
Serc/Alve
TOPAZ:a tool kit for the assembly of transaction managers for non-standard applications
'Advanced database applications', such as CAD/CAM, CASE, large AI applications or image and voice processing, place demands on transaction management which differ substantially from those in traditional database applications. In particular, there is a need to support 'enriched' data models (which include, for example, complex objects or version and configuration management), 'synergistic' cooperative work, and application- or user-supported consistency. Unfortunately, the demands are not only sophisticated but also diversified, which means that different application areas might even place contradictory demands on transaction management. This paper deals with these problems and offers a solution by introducing a flexible and adaptable tool kit approach for transaction management
Acquisition of computer research equipment
Issued as Final report, Project no. G-36-61
Transaction management on collaborative application services
Thesis (M.Eng.)--Massachusetts Institute of Technology, Dept. of Civil and Environmental Engineering, 2000.Includes bibliographical references (leaves 86-87).by Koon-Po Paul Wong.M.Eng
Selective transparency in distributed transaction processing
PhD ThesisObject-oriented programming languages provide a powerful interface for
programmers to access the mechanisms necessary for reliable distributed
computing. Using inheritance and polymorphism provided by the object model, it
is possible to develop a hierarchy of classes to capture the semantics and
inter-relationships of various levels of functionality required for distributed
transaction processing. Using multiple inheritance, application developers can
selectively apply transaction properties to suit the requirements of the application
objects.
In addition to the specific problems of (distributed) transaction processing in an
environment of persistent objects, there is a need for a unified framework, or
architecture in which to place this system. To be truly effective, not only the
transaction manager, but the entire transaction support environment must be
described, designed and implemented in terms of objects.
This thesis presents an architecture for reliable distributed processing in which
the management of persistence, provision of transaction properties (e.g.,
concurrency control), and organisation of support services (e.g., RPC) are all
gathered into a unified design based on the object model.UK Science and Engineering Council:
ESPRIT project
Object Management for Persistence and Recoverability
PhD ThesisAs distribution becomes commonplace, there is a growing requirement for
applications that behave reliably when node or network failures occur. To
support reliability, operations on the components of a distributed application may
be declared to occur within the scope of an atomic action. This thesis describes
how atomic actions may be supported in an environment consisting of
applications that operate on objects.
To support the failure atomicity and permanence of effect properties of an
atomic action, the objects accessed within the scope of an atomic action must be
recoverable and persistent. This thesis describes how these properties may be
added to the class of an object. The approach adopted is to provide a class that
implements recovery and persistence mechanisms, and derive new classes from
this base class. By refining inherited operations so that recovery and persistence
is specific to that class, recoverable and persistent objects may be easily produced.
This thesis also describes how an atomic action may be implemented as a
class, so that instances of the class are atomic actions which manage the
recoverable and persistent objects. Multiple instance declarations produce nested
atomic actions, and the atomic action class also inherits persistence so that shortterm
commit information may be saved in an object store which is used to
maintain the passive state of persistent objects.
Since the mechanisms and classes that support recovery, persistence, and
atomic actions are constructed using the feature of an object-oriented language,
they may be implemented in environments that provide suitable support for
objects and object-oriented programming languages.Science and
Engineering Research Council,
SERC/Alve
Improving Reuse of Distributed Transaction Software with Transaction-Aware Aspects
Implementing crosscutting concerns for transactions is difficult, even using Aspect-Oriented Programming Languages (AOPLs) such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources. Current AOPLs do not provide joinpoints and pointcuts for weaving advice into high-level abstractions or contexts, like transaction contexts. Other challenges stem from the essential complexity in the nature of the data, operations on the data, or the volume of data, and accidental complexity comes from the way that the problem is being solved, even using common transaction frameworks. This dissertation describes an extension to AspectJ, called TransJ, with which developers can implement transaction-related crosscutting concerns in cohesive and loosely-coupled aspects. It also presents a preliminary experiment that provides evidence of improvement in reusability without sacrificing the performance of applications requiring essential transactions. This empirical study is conducted using the extended-quality model for transactional application to define measurements on the transaction software systems. This quality model defines three goals: the first relates to code quality (in terms of its reusability); the second to software performance; and the third concerns software development efficiency. Results from this study show that TransJ can improve the reusability while maintaining performance of TransJ applications requiring transaction for all eight areas addressed by the hypotheses: better encapsulation and separation of concern; loose Coupling, higher-cohesion and less tangling; improving obliviousness; preserving the software efficiency; improving extensibility; and hasten the development process
Validity contracts for software transactions
Software Transactional Memory is a promising approach to concurrent programming, freeing programmers from error-prone concurrency control decisions that are complicated and not composable. But few such systems address consistencies of transactional objects.
In this thesis, I propose a contract-based transactional programming model toward more secure transactional softwares. In this general model, a validity contract specifies both requirements and effects for transactions. Validity contracts bring numerous benefits including reasoning about and verifying transactional programs, detecting and resolving transactional conflicts, automating object revalidation and easing program debugging.
I introduce an ownership-based framework, namely AVID, derived from the general model, using object ownership as a mechanism for specifying and reasoning validity contracts. I have specified a formal type system and implemented a prototype type checker to support static checking. I also have built a transactional library framework AVID, based on existing Java DSTM2 framework, for expressing transactions and validity contracts.
Experimental results on a multi-core system show that contracts add little overheads to the original STM. I find that contract-aware contention management yields significant speedups in some cases. The results have suggested compiler directed optimisation for tunning contract-based transactional programs. My further work will investigate the applications of transaction contracts on various aspects of TM research such as hardware support and open-nesting
Fault tolerance distributed computing
Issued as Funds expenditure reports [nos. 1-4], Quarterly progress reports [nos. 1-3], and Final report, Project no. G-36-63
- …