Team VASY

Members
Overall Objectives
Application Domains
Software
New Results
Contracts and Grants with Industry
Other Grants and Activities
Dissemination
Bibliography
Inria / Raweb 2004
Project: VASY

Project : vasy

Section: New Results


Languages and Compilation Techniques

Compilation of the LOTOS Data Part

Participants : David Champelovier, Hubert Garavel.

In 2004, we deeply modified the Cæsar.adt compiler for the data part of Lotos so as to implement a feature requested by many users around the world.

Enumerative verification for specifications that contain typed values may require to enumerate exhaustively the domains of certain types, i.e., the set of all values of certain types. To do this, Cæsar.adt generates automatically iterators (i.e., fragments of C code) suitable for enumerating Lotos types, which are basically data types defined by a set of free constructors. Obviously, this can only be done for types with a finite domain. Cæsar.adt also accepts iterators written by the user manually.

So far, the iterators generated automatically by Cæsar.adt were restricted to certain classes of Lotos types: (bounded) natural numbers, enumerated types, and tuple types. The changes brought to Cæsar.adt in 2004 allow iterators to be generated for all finite Lotos types, including the intricate case of union types, which might be nested at any depth.

This improvement required a deep modification of the concept of iterators and the addition of 1, 000 new lines of code in Cæsar.adt. In the former version of Cæsar.adt, an old-style iterator consisted of one single C macro-definition (similar to a ``for''-loop), whereas in the modified versions of Cæsar.adt, a new-style iterator consists of two companion C macro-definitions (based on a ``first/next'' scheme).

A key issue was to maintain, as much as possible, backward compatibility with former versions of Cæsar.adt, in particular by accepting old-style iterators already written by the users manually. In most cases, the change is transparent to the end-user; otherwise, error messages are emitted, which will disappear after minor modifications by the user.

The Cæsar compiler, the predefined Lotos data type libraries, and the Cadp demo examples have been updated so as to take advantage of new-style iterators.

Compilation of the LOTOS Process Part

Participants : Damien Bergamini, Hubert Garavel, Wendelin Serwe.

In 2004, we enhanced in several ways the Cæsar compiler for the process part of Lotos:

Compilation of E-LOTOS

Participants : Aurore Collomb, David Champelovier, Hubert Garavel, Frédéric Lang.

As regards the data part of E-Lotos, we continued to improve the Traian compiler (see §  5.2), which is distributed on the Internet (see §  9.1) and used intensively within the Vasy team as a development tool for compiler construction [7].

In 2004, we released a new version 2.4 of Traian, which corrects two bugs of the previous version 2.3 issued in 2003. In addition, we ported the Traian compiler to the Mac OS X and recent Linux operating systems.

We also continued to work on the compilation of the process part of E-Lotos and Lotos NT, which is a difficult problem as these languages combine concurrency, quantitative time, and exceptions. To deal with these problems progressively, we chose to focus first on the sequential processes present in E-Lotos and Lotos NT. In 2002, we designed a formalism named Ntif (New Technology Intermediate Form) to be used as an intermediate language for compiling and verifying E-Lotos and Lotos NT processes.

Ntif allows to specify extended automata parameterized by typed variables. Each transition is labeled with an action (which allows communication with the environment according to the rendezvous semantics of process algebras) and a sequential code fragment to read and/or write variables. Compared to classical ``condition/action'' (or ``guarded commands'') automata, Ntif provides high level control structures (statements ``case'', ``if-then-else'', ``while'', etc.); this avoids the introduction of spurious intermediate states and transitions, as well as the duplication of boolean conditions, an important source of errors [6].

Since 2003, Ntif also features quantitative time concepts, in the form of a ``wait'' operator that lets a given amount of time elapse, timing tags on actions to express deadline and urgency, and a construct to capture the time elapsed between the instant an action is enabled and the instant it actually occurs.

In 2004, we revised and simplified the semantics of timed Ntif automata, by observing that properties inherent to time (namely time additivity, time determinism, and maximal progress) can be decoupled from the structural semantics definition. To this aim, we defined a time equivalence relation on Timed Labeled Transition Systems, the underlying model of Ntif. This lead to structural operational semantics rules that are lightweight extensions of the untimed rules. Besides Ntif, this approach could be used to simplify the (generally complex) semantics of many timed process algebras.

Source-Level Translations between Process Algebras

Participants : Hubert Garavel, Frédéric Lang, Gwen Salaün.

Although process algebras are, from a technical point of view, the best formalism to describe concurrent systems, they are not used as widely as it could be. Besides the steep learning curve of process algebras, which is traditionally mentioned as the main reason for this situation, it seems also that the process algebra community scattered its efforts by developing too many languages, similar in concept but incompatible in practice. Even the advent of two international standards, such as Lotos (in 1989) and E-Lotos (in 2001), did not remedy to this fragmentation.

Because of this, process algebras other than Lotos do not benefit from the advanced functionalities provided by the Cadp toolbox. In 2004, we started to address this problem by designing source-level translators from various process algebras into Lotos.

In the framework of the Inria/Leti collaboration (see §  8.1), we focused on the process algebra Chp (Communicating Hardware Processes) for which the Tima laboratory has developed a circuit synthesis tool named Tast and which is used by the Leti laboratory to describe complex, asynchronous circuits at a high abstraction level.

G. Salaün undertook the development of a translator from Chp to Lotos (currently, 2, 130 lines of Syntax compiler-generator code, 1, 970 lines of Lotos NT code, and 350 lines of C code). When completed, this translator should allow Chp designs to be verified using Cadp before being turned into asynchronous circuits using Tast.

Besides the case of Chp, G. Salaün started studying translators for other process algebras, including Csp/Fdr2 and Fsp.


previous
next

Logo Inria