284,096 research outputs found
Preserving Liveness Guarantees from Synchronous Communication to Asynchronous Unstructured Low-Level Languages
In the implementation of abstract synchronous communication in asynchronous unstructured low-level languages, e.g. using shared variables, the preservation of safety and especially liveness properties is a hitherto open problem due to inherently different abstraction levels. Our approach to overcome this problem is threefold: First, we present our notion of handshake refinement with which we formally prove the correctness of the implementation relation of a handshake protocol. Second, we verify the soundness of our handshake refinement, i.e., all safety and liveness properties are preserved to the lower level. Third, we apply our handshake refinement to show the correctness of all implementations that realize the abstract synchronous communication with the handshake protocol. To this end, we employ an exemplary language with asynchronous shared variable communication. Our approach is scalable and closes the verification gap between different abstraction levels of communication
Testing refinements by refining tests
One of the potential benefits of formal methods is that they offer the possibility of reducing the costs of testing. A specification acts as both the benchmark against which any implementation is tested, and also as the means by which tests are generated. There has therefore been interest in developing test generation techniques from formal specifications, and a number of different methods have been derived for state based languages such as Z, B and VDM. However, in addition to deriving tests from a formal specification, we might wish to refine the specification further before its implementation. The purpose of this paper is to explore the relationship between testing and refinement. As our model for test generation we use a DNF partition analysis for operations written in Z, which produces a number of disjoint test cases for each operation. In this paper we discuss how the partition analysis of an operation alters upon refinement, and we develop techniques that allow us to refine abstract tests in order to generate test cases for a refinement. To do so we use (and extend existing) methods for calculating the weakest data refinement of a specification
Feature refinement
Development by formal stepwise refinement offers a guarantee that an implementation satisfies a specification. But refinement is frequently defined in such a restrictive way as to disallow some useful development steps. Here we de- fine feature refinement to overcome some limitations of re- finement and show its usefulness by applying it to examples taken from the literature.
Using partial relations as a canonical state-based semantics and labelled transition systems as a canonical event-based semantics, we degine functions formally linking the state- and event-based operational semantics. We can then use this link to move notions of refinement between the event- and state-based worlds.
An advantage of this abstract approach is that it is not restricted to a specific syntax or even a specific interpretation of the operational semantic
On a New Notion of Partial Refinement
Formal specification techniques allow expressing idealized specifications,
which abstract from restrictions that may arise in implementations. However,
partial implementations are universal in software development due to practical
limitations. Our goal is to contribute to a method of program refinement that
allows for partial implementations. For programs with a normal and an
exceptional exit, we propose a new notion of partial refinement which allows an
implementation to terminate exceptionally if the desired results cannot be
achieved, provided the initial state is maintained. Partial refinement leads to
a systematic method of developing programs with exception handling.Comment: In Proceedings Refine 2013, arXiv:1305.563
Achieving Extreme Resolution in Numerical Cosmology Using Adaptive Mesh Refinement: Resolving Primordial Star Formation
As an entry for the 2001 Gordon Bell Award in the "special" category, we
describe our 3-d, hybrid, adaptive mesh refinement (AMR) code, Enzo, designed
for high-resolution, multiphysics, cosmological structure formation
simulations. Our parallel implementation places no limit on the depth or
complexity of the adaptive grid hierarchy, allowing us to achieve unprecedented
spatial and temporal dynamic range. We report on a simulation of primordial
star formation which develops over 8000 subgrids at 34 levels of refinement to
achieve a local refinement of a factor of 10^12 in space and time. This allows
us to resolve the properties of the first stars which form in the universe
assuming standard physics and a standard cosmological model. Achieving extreme
resolution requires the use of 128-bit extended precision arithmetic (EPA) to
accurately specify the subgrid positions. We describe our EPA AMR
implementation on the IBM SP2 Blue Horizon system at the San Diego
Supercomputer Center.Comment: 23 pages, 5 figures. Peer reviewed technical paper accepted to the
proceedings of Supercomputing 2001. This entry was a Gordon Bell Prize
finalist. For more information visit http://www.TomAbel.com/GB
- …