The Experts below are selected from a list of 1776 Experts worldwide ranked by ideXlab platform
John Derrick - One of the best experts on this subject based on the ideXlab platform.
-
Proving linearisability via coarse-grained abstraction
arXiv: Logic in Computer Science, 2012Co-Authors: Brijesh Dongol, John DerrickAbstract:Linearisability has become the standard safety criterion for concurrent data structures ensuring that the effect of a concrete operation takes place after the execution some Atomic Statement (often referred to as the linearisation point). Identification of linearisation points is a non-trivial task and it is even possible for an operation to be linearised by the execution of other concurrent operations. This paper presents a method for verifying linearisability that does not require identification of linearisation points in the concrete code. Instead, we show that the concrete program is a refinement of some coarse-grained abstraction. The linearisation points in the abstraction are straightforward to identify and the linearisability proof itself is simpler due to the coarse granularity of its Atomic Statements. The concrete fine-grained program is a refinement of the coarse-grained program, and hence is also linearisable because every behaviour of the concrete program is a possible behaviour its abstraction.
-
Proving linearisability without linearisation points An interval-based approach
2012Co-Authors: Brijesh Dongol, John Derrick, Lindsay Groves, Ian J. HayesAbstract:Linearisability has become the standard safety condition for concurrent data structures, which ensures that the effect of a concrete operation takes place after the execution some Atomic Statement (often referred to as the linearisation point) of a concurrent operation. Identification of linearisation points is a non-trivial task and it is even possible for an operation to be linearised by the execution of other concurrent operations. This paper presents a verification method where we verify linearisability of a coarse-grained abstraction of the concurrent data structure; the linearisation points in the coarse-grained abstraction are straightforward to identify. We then show that the concrete fine-grained program is an implementation of the coarse-grained abstraction.
Brijesh Dongol - One of the best experts on this subject based on the ideXlab platform.
-
Proving linearisability via coarse-grained abstraction
arXiv: Logic in Computer Science, 2012Co-Authors: Brijesh Dongol, John DerrickAbstract:Linearisability has become the standard safety criterion for concurrent data structures ensuring that the effect of a concrete operation takes place after the execution some Atomic Statement (often referred to as the linearisation point). Identification of linearisation points is a non-trivial task and it is even possible for an operation to be linearised by the execution of other concurrent operations. This paper presents a method for verifying linearisability that does not require identification of linearisation points in the concrete code. Instead, we show that the concrete program is a refinement of some coarse-grained abstraction. The linearisation points in the abstraction are straightforward to identify and the linearisability proof itself is simpler due to the coarse granularity of its Atomic Statements. The concrete fine-grained program is a refinement of the coarse-grained program, and hence is also linearisable because every behaviour of the concrete program is a possible behaviour its abstraction.
-
Proving linearisability without linearisation points An interval-based approach
2012Co-Authors: Brijesh Dongol, John Derrick, Lindsay Groves, Ian J. HayesAbstract:Linearisability has become the standard safety condition for concurrent data structures, which ensures that the effect of a concrete operation takes place after the execution some Atomic Statement (often referred to as the linearisation point) of a concurrent operation. Identification of linearisation points is a non-trivial task and it is even possible for an operation to be linearised by the execution of other concurrent operations. This paper presents a verification method where we verify linearisability of a coarse-grained abstraction of the concurrent data structure; the linearisation points in the coarse-grained abstraction are straightforward to identify. We then show that the concrete fine-grained program is an implementation of the coarse-grained abstraction.
Richard F. W. Bader - One of the best experts on this subject based on the ideXlab platform.
-
Transferability of group energies and satisfaction of the virial theorem
Chemical Physics Letters, 2003Co-Authors: Fernando Cortés-guzmán, Richard F. W. BaderAbstract:The theory of atoms in molecules equates the energy of a group to the negative of its electronic kinetic energy, using the Atomic Statement of the virial theorem. In general, a correction must be applied because of the failure of the wave function to satisfy the virial theorem. This Letter examines the transferability of group energies using self-consistently scaled wave functions that satisfy the virial theorem at both single determinant and correlated levels of theory to demonstrate that apparent deviations in the transferability of the group energies found in certain homologous systems, is an artefact arising from the variation in the virial correction factor.
-
Variational principle and path integrals for atoms in molecules
International Journal of Quantum Chemistry, 1992Co-Authors: P. F. Zou, Richard F. W. BaderAbstract:Two things were done in this paper: (i) A generalization of Schwinger's variational principle to a subsystem was developed within the framework of quantum field theory and applied to the theory of atoms in molecules. This work generalizes the previous derivation given in the Schrodinger formulation. (ii) It is demonstrated that Feynman's path integral, when expressed in terms of the coherent-state representation, can be constructed for a subsystem of a many-electron system if a divergence term, which serves as a variational constraint in the definition of an atom in a molecule, is added to the Lagrangian. This formulation is equivalent to the Atomic Statement of the variational principle if the divergence term is suitably constructed. It is shown that the path integral can be expressed as a product of the individual Atomic contributions to the steps along the paths with the action being determined by a corresponding sum of the Atomic contributions to the action integral. © 1992 John Wiley & Sons, Inc.
Vegard Veiset - One of the best experts on this subject based on the ideXlab platform.
-
PNSE+ModPE - Transforming Platform Independent CPN Models into Code for the TinyOS Platform: A Case Study of the RPL Protocol
2013Co-Authors: Lars Michael Kristensen, Vegard VeisetAbstract:TinyOS is a widely used platform for the development of networked embedded systems offering a programming model targeting resource constrained devices. We present a software engineering approach where Coloured Petri Net (CPNs) models are used as a starting point for developing protocol software for the TinyOS platform. The approach consists of five refinement steps where a platform-independent CPN model is gradually transformed into a platform-specific model that enables automatic code generation. To evaluate our approach, we use it to obtain an implementation of the IETF RPL routing protocol for sensor networks. Introduction. Model-based software engineering and verification have several attractive properties in the development of flexible and reliable software systems. In order to fully leverage modelling investments, it is desireable to use the constructed models also for the implementation of the software on the platform under consideration. Coloured Petri Nets [2] (and Petri Nets in general) constitute a general purpose modelling language supporting platform-independent modelling of concurrent systems. Hence, in most cases, such models are too abstract to be used directly to implement software. In order to bridge the gap between abstract and platform independent CPN models and the implementation of software to be deployed, the concept of pragmatics was introduced in [4]. Pragmatics are syntactical annotations that can be added to a CPN model and used to direct code generation for a specific platform. The contribution of this paper is an approach [5] that exploits pragmatics in combination with a five step refinement methodology to enable code generation for the TinyOS platform. Applications for TinyOS [3] are implemented using the nesC programming language (a dialect of C) providing an event-based split-phase programming model. An application written in nesC is organised into a wired set of modules each providing an interface consisting of commands and events. Refinement Steps. The model refinement starts from a platform independent CPN model constructed typically with the aim of specifying the protocol operation and performing model checking of the protocol design. Each step consists of a transformation that uses the constructs of the CPN modelling language to add details to the model. Furthermore, in each step pragmatics are added that direct the code generation performed after the fifth step: Step 1: Component Architecture consists of annotating CPN submodules and substitution transitions corresponding to TinyOS components, and make explicit the interfaces used and provided by components. Step 2: Resolving Interface Conflicts resolves interface conflicts allowing components to use multiple instances of an interface. This is done by annotating CPN arcs with information providing locally unique names. Step 3: Component and Interface Signature adds type signatures to components and interfaces by creating explicit submodules for command and events, and by refining colour sets to reflect the interface signatures. Step 4: Component Classification further refines the components by classifying them into four main types: timed, external, boot, and generic. Step 5: Internal Component Behaviour consists of refining the modelling of the individual commands and events such that control flow and data manipulation become explicit and organised into Atomic Statement blocks. After the fifth refinement step has been performed, the CPN model includes sufficient detail to be used as a basis for automated code generation. The RPL Protocol and Code Generation. To evaluate our approach on an industrial-sized example, we have conducted a case study based on the RPL routing protocol [1] developed by the Internet Engineering Task Force. The RPL protocol allows a set of sensor nodes to construct a destination-oriented directed acyclic graph which can be used for multi-hop communication between sensor nodes. To support the automatic code generation for TinyOS, we have developed a software prototype in Java that performs a template-based model-to-text transformation on the models resulting from the fifth refinement step. The software prototype relies on the Access/CPN framework [6] to load CPN models created with CPN Tools. The code generator performs a top-down traversal of the CPN model where code templates are selected according to the pragmatic annotations on the CPN model elements encountered.
Richard Zach - One of the best experts on this subject based on the ideXlab platform.
-
LPAR - Tableaux for Reasoning About Atomic Updates
Logic for Programming Artificial Intelligence and Reasoning, 2001Co-Authors: Christian G. Fermüller, Georg Moser, Richard ZachAbstract:A simple model of dynamic databases is studied from a modal logic perspecitve. A state α of a database is an Atomic update of a state β if at most one Atomic Statement is evaluated differently in α compared to β. The corresponding restriction on Kripke-like structures yields so-called update logics. These logics are studied also in a many-valued context. Adequate tableau calculi are given.
