11,530 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
Integrating Object-Oriented Programming and Protected Objects in Ada 95
Integrating concurrent and object-oriented programming as been an active research topic since the late 1980s. There is now a plethora of methods for achieving this integration. The majority of approaches have taken a sequential object-oriented language and made it concurrent. A few approaches have taken a concurrent language and made it object-oriented. The most important of this latter case is the Ada 95 language which is an extension to the object-based concurrent programming language Ada 83. Arguably, Ada 95 does not fully integrate its models of concurrency and object-oriented programming. For example. neither tasks nor protected objects are extensible. This paper discusses ways in which protected objects can be made more extensible
Compensation methods to support cooperative applications: A case study in automated verification of schema requirements for an advanced transaction model
Compensation plays an important role in advanced transaction models, cooperative work and workflow systems. A schema designer is typically required to supply for each transaction another transaction to semantically undo the effects of . Little attention has been paid to the verification of the desirable properties of such operations, however. This paper demonstrates the use of a higher-order logic theorem prover for verifying that compensating transactions return a database to its original state. It is shown how an OODB schema is translated to the language of the theorem prover so that proofs can be performed on the compensating transactions
Towards Practical Graph-Based Verification for an Object-Oriented Concurrency Model
To harness the power of multi-core and distributed platforms, and to make the
development of concurrent software more accessible to software engineers,
different object-oriented concurrency models such as SCOOP have been proposed.
Despite the practical importance of analysing SCOOP programs, there are
currently no general verification approaches that operate directly on program
code without additional annotations. One reason for this is the multitude of
partially conflicting semantic formalisations for SCOOP (either in theory or
by-implementation). Here, we propose a simple graph transformation system (GTS)
based run-time semantics for SCOOP that grasps the most common features of all
known semantics of the language. This run-time model is implemented in the
state-of-the-art GTS tool GROOVE, which allows us to simulate, analyse, and
verify a subset of SCOOP programs with respect to deadlocks and other
behavioural properties. Besides proposing the first approach to verify SCOOP
programs by automatic translation to GTS, we also highlight our experiences of
applying GTS (and especially GROOVE) for specifying semantics in the form of a
run-time model, which should be transferable to GTS models for other concurrent
languages and libraries.Comment: In Proceedings GaM 2015, arXiv:1504.0244
- ā¦