22,250 research outputs found
PALS-Based Analysis of an Airplane Multirate Control System in Real-Time Maude
Distributed cyber-physical systems (DCPS) are pervasive in areas such as
aeronautics and ground transportation systems, including the case of
distributed hybrid systems. DCPS design and verification is quite challenging
because of asynchronous communication, network delays, and clock skews.
Furthermore, their model checking verification typically becomes unfeasible due
to the huge state space explosion caused by the system's concurrency. The PALS
("physically asynchronous, logically synchronous") methodology has been
proposed to reduce the design and verification of a DCPS to the much simpler
task of designing and verifying its underlying synchronous version. The
original PALS methodology assumes a single logical period, but Multirate PALS
extends it to deal with multirate DCPS in which components may operate with
different logical periods. This paper shows how Multirate PALS can be applied
to formally verify a nontrivial multirate DCPS. We use Real-Time Maude to
formally specify a multirate distributed hybrid system consisting of an
airplane maneuvered by a pilot who turns the airplane according to a specified
angle through a distributed control system. Our formal analysis revealed that
the original design was ineffective in achieving a smooth turning maneuver, and
led to a redesign of the system that satisfies the desired correctness
properties. This shows that the Multirate PALS methodology is not only
effective for formal DCPS verification, but can also be used effectively in the
DCPS design process, even before properties are verified.Comment: In Proceedings FTSCS 2012, arXiv:1212.657
Recommended from our members
EXEL : a language for interactive behavioral synthesis
This paper describes a new input language for behavioral synthesis called EXEL. EXEL is a powerful language that permits the user to specify partially designed structures in the language. It employs a mixed graphic/textual user interface to enhance user interactivity. EXEL's design model is comprehensive: it permits specification of synchronous and asynchronous behavior, and allows specification of general timing constraints. A flexible type construct permits the user to define operators and components to be used in the description. Finally, it simplifies compilation by using a small set of constructs for specifying timing and asynchronouos behavior. The compiler for EXEL runs on SUN-3 workstations and is written in C and SUNVIEW
Coordination of Dynamic Software Components with JavaBIP
JavaBIP allows the coordination of software components by clearly separating
the functional and coordination aspects of the system behavior. JavaBIP
implements the principles of the BIP component framework rooted in rigorous
operational semantics. Recent work both on BIP and JavaBIP allows the
coordination of static components defined prior to system deployment, i.e., the
architecture of the coordinated system is fixed in terms of its component
instances. Nevertheless, modern systems, often make use of components that can
register and deregister dynamically during system execution. In this paper, we
present an extension of JavaBIP that can handle this type of dynamicity. We use
first-order interaction logic to define synchronization constraints based on
component types. Additionally, we use directed graphs with edge coloring to
model dependencies among components that determine the validity of an online
system. We present the software architecture of our implementation, provide and
discuss performance evaluation results.Comment: Technical report that accompanies the paper accepted at the 14th
International Conference on Formal Aspects of Component Softwar
Modularizing and Specifying Protocols among Threads
We identify three problems with current techniques for implementing protocols
among threads, which complicate and impair the scalability of multicore
software development: implementing synchronization, implementing coordination,
and modularizing protocols. To mend these deficiencies, we argue for the use of
domain-specific languages (DSL) based on existing models of concurrency. To
demonstrate the feasibility of this proposal, we explain how to use the model
of concurrency Reo as a high-level protocol DSL, which offers appropriate
abstractions and a natural separation of protocols and computations. We
describe a Reo-to-Java compiler and illustrate its use through examples.Comment: In Proceedings PLACES 2012, arXiv:1302.579
A design method for modular energy-aware software
Nowadays achieving green software by reducing the overall energy consumption of the software is becoming more and more important. A well-known solution is to make the software energy-aware by extending its functionality with energy optimizers, which monitor the energy consumption of software and adapt it accordingly. Modular design of energy-aware software is necessary to make the extensions manageable and to cope with the complexity of the software. To this aim, we require suitable methods that guide designers through the necessary design activities and the models that must be prepared during each activity. Despite its importance, such a method is not investigated in the literature. This paper proposes a dedicated design method for energy-aware software, discusses a concrete realization of this method, and—by means of a concrete example—illustrates the suitability of this method in achieving modularity
Prototyping the Semantics of a DSL using ASF+SDF: Link to Formal Verification of DSL Models
A formal definition of the semantics of a domain-specific language (DSL) is a
key prerequisite for the verification of the correctness of models specified
using such a DSL and of transformations applied to these models. For this
reason, we implemented a prototype of the semantics of a DSL for the
specification of systems consisting of concurrent, communicating objects. Using
this prototype, models specified in the DSL can be transformed to labeled
transition systems (LTS). This approach of transforming models to LTSs allows
us to apply existing tools for visualization and verification to models with
little or no further effort. The prototype is implemented using the ASF+SDF
Meta-Environment, an IDE for the algebraic specification language ASF+SDF,
which offers efficient execution of the transformation as well as the ability
to read models and produce LTSs without any additional pre or post processing.Comment: In Proceedings AMMSE 2011, arXiv:1106.596
Structural Synthesis for GXW Specifications
We define the GXW fragment of linear temporal logic (LTL) as the basis for
synthesizing embedded control software for safety-critical applications. Since
GXW includes the use of a weak-until operator we are able to specify a number
of diverse programmable logic control (PLC) problems, which we have compiled
from industrial training sets. For GXW controller specifications, we develop a
novel approach for synthesizing a set of synchronously communicating
actor-based controllers. This synthesis algorithm proceeds by means of
recursing over the structure of GXW specifications, and generates a set of
dedicated and synchronously communicating sub-controllers according to the
formula structure. In a subsequent step, 2QBF constraint solving identifies and
tries to resolve potential conflicts between individual GXW specifications.
This structural approach to GXW synthesis supports traceability between
requirements and the generated control code as mandated by certification
regimes for safety-critical software. Synthesis for GXW specifications is in
PSPACE compared to 2EXPTIME-completeness of full-fledged LTL synthesis. Indeed
our experimental results suggest that GXW synthesis scales well to
industrial-sized control synthesis problems with 20 input and output ports and
beyond.Comment: The long (including appendix) version being reviewed by CAV'16
program committee. Compared to the submitted version, one author (out of her
wish) is moved to the Acknowledgement. (v2) Corrected typos. (v3) Add an
additional remark over environment assumption and easy corner case
Extending the Real-Time Maude Semantics of Ptolemy to Hierarchical DE Models
This paper extends our Real-Time Maude formalization of the semantics of flat
Ptolemy II discrete-event (DE) models to hierarchical models, including modal
models. This is a challenging task that requires combining synchronous
fixed-point computations with hierarchical structure. The synthesis of a
Real-Time Maude verification model from a Ptolemy II DE model, and the formal
verification of the synthesized model in Real-Time Maude, have been integrated
into Ptolemy II, enabling a model-engineering process that combines the
convenience of Ptolemy II DE modeling and simulation with formal verification
in Real-Time Maude.Comment: In Proceedings RTRTS 2010, arXiv:1009.398
- …