Pertti Kellomäki

Verification of Reactive Systems Using DisCo and PVS

We have provided mechanical verification support for DisCo, an object oriented language and method for the specification of reactive systems. The paper has two main contributions. The first one is a mapping of object oriented specifications to the PVS theorem prover, where their invariant properties can be mechanically verified. The second one is the use of the theorem prover together with the animation facility of the DisCo environment when strengthening invariants.

Design Templates for Collective Behavior

While sequential behavior of single objects is fairly well understood, orchestrating the collective behavior emerging from the behaviors of individual objects continues to be a challenging task. This is especially true for distributed reactive systems. The joint action paradigm is a design methodology that concentrates on the collective behavior of objects. Aspects of collective behavior are gradually introduced in a controlled manner in a specification. This paper presents how such aspects can be archived as generic templates, and instantiated in such a way that formal properties verified for a template become properties of its application. Both design and verification effort are reused when a template is applied.

Impact of Software Bypassing on Instruction Level Parallelism and Register File Traffic

Software bypassing is a technique that allows programmer-controlled direct transfer of results of computations to the operands of data dependent operations, possibly removing the need to store some values in general purpose registers, while reducing the number of reads from the register file. Software bypassing also improves instruction level parallelism by reducing the number of false dependencies between operations caused by the reuse of registers. In this work we show how software bypassing affects cycle count and reduces register file reads and writes. We analyze previous register file bypassing methods and compare them with our improved software bypassing implementation. In addition, we propose heuristics when not to apply software bypassing to retain scheduling freedom when selecting function units for operations. The results show that we get at best 27% improvement to cycle count, as well as up to 48% less register reads and 45% less register writes with the use of bypassing.

A Structural Embedding of Ocsid in PVS

We describe a structural embedding of the Ocsid specification language into the logic of the PVS theorem prover. A front end tool is used to manipulate the structural elements of the language, while the expression language is directly borrowed from the theorem prover. The structural embedding allows us to express and verify invariant properties of distributed systems in an abstract form. An invariant can be verified once, and reused multiple times by discharging a set of relatively simple proof obligations.

Reducing processor energy consumption by compiler optimization

Purpose of embedded computing is to transform input data to output format. Functionality required to achieve this goal is therefore combination of operation executions on computing units and data transfers between those units. To avoid memory bottlenecks, processors use register files to store data during computation.

Energy consumption reduction by automatic selection of compiler options

This paper presents a statistical approach of finding a set of optimum compiler options to minimize the energy consumption of the compiled executable. The method employs a statistical, non-parametric analysis, namely the Mann-Whitney test, to determine a set of options to be turned on and off for a particular source code. Energy measurements show that an improvement of up to 15% over the default optimization set up of the compiler can be achieved with this methodology.

Coordinating Aspects and Objects

Abstract Conventional software architectures emphasize individual software components and their interconnections. While offering many advantages this results in problems with concerns that cut across the component structure. The code addressing such concerns is scattered around the components and tangled with some other code inside the components. Approaches addressing such issues are emerging with new paradigms like aspect-oriented programming. However, aspects addressing cross-cutting concerns need to be incorporated in an object-oriented design without support from a higher-level design. We propose an approach where aspects and objects rely on coordination provided by a common high level specification. The common specification links the parts of specification that are refined independently and implemented using different techniques. We use the formal specification method DisCo, and demonstrate the approach by providing a specification of a simplified telecommunications system. In addition, we also sketch an Aspect J implementation built in the architectural style encouraged by the method. Funding from Tampere Graduate School in Information Science and Engineering (TISE) and the Academy of Finland (project 100005) is gratefully acknowledged.

Reducing Context Switch Overhead with Compiler-Assisted Threading

Multithreading is an important software modularization technique. However, it can incur substantial overheads, especially in processors where the amount of architecturally visible state is large. We propose an implementation technique for co-operative multithreading, where context switches occur in places that minimize the amount of state that needs to be saved. The subset of processor state saved during each context switch is based on where the switch occurs.We have validated the approach by an empirical study of resource usage in basic blocks, and by implementing the co-operative threading in our compiler. Performance figures are given for an MP3 player utilizing the threading implementation.

Modeling distributed stated as an abstract object

Object-oriented software development emphasizes the use of abstractions. Inheritance is used for factoring common structure and functionality to abstract classes, providing abstract interfaces to objects. This helps in avoiding premature implementation bias.

Composing distributed systems from reusable aspects of behavior

Research on aspect oriented programming and specification has highlighted the need to deal with cross-cutting concerns that involve more than one implementation level component. Distributed systems are an important application area where cross-cutting concerns frequently emerge. We present a novel way of composing distributed behavior from reusable superposition steps. The steps are given in a joint action notation, which allows the introducing of logically related data and operations in several implementation level components simultaneously. A superposition step contains a description of the context in which it is applicable, and the additional structure to add to a specification. Aspects of collective behavior may overlap at the implementation level. To make it possible to separate aspects cleanly at the specification level, our specification method allows entities to be merged in composition to allow an implementation level entity to play multiple specification level roles.