90 research outputs found
Automatic Optimizations for Stream-based Monitoring Languages
Runtime monitors that are specified in a stream-based monitoring language
tend to be easier to understand, maintain, and reuse than those written in a
standard programming language. Because of their formal semantics, such
specification languages are also a natural choice for safety-critical
applications. Unlike for standard programming languages, there is, however, so
far very little support for automatic code optimization. In this paper, we
present the first collection of code transformations for the stream-based
monitoring language RTLola. We show that classic compiler optimizations, such
as Sparse Conditional Constant Propagation and Common Subexpression
Elimination, can be adapted to monitoring specifications. We also develop new
transformations -- Pacing Type Refinement and Filter Refinement -- which
exploit the specific modular structure of RTLola as well as the implementation
freedom afforded by a declarative specification language. We demonstrate the
significant impact of the code transformations on benchmarks from the
monitoring of unmanned aircraft systems (UAS).Comment: 20th International Conference on Runtime Verification (2020
On the automatic construction of indistinguishable operations
An increasingly important design constraint for software running
on ubiquitous computing devices is security, particularly against
physical methods such as side-channel attack. One well studied methodology
for defending against such attacks is the concept of indistinguishable
functions which leak no information about program control
flow since all execution paths are computationally identical. However,
constructing such functions by hand becomes laborious and error prone
as their complexity increases. We investigate techniques for automating
this process and find that effective solutions can be constructed with
only minor amounts of computational effort.Fundação para a CiĂȘncia e Tecnologia - SFRH/BPD/20528/2004
The Cache-Oblivious Gaussian Elimination Paradigm: Theoretical Framework, Parallelization and Experimental Evaluation
A formally verified compiler back-end
This article describes the development and formal verification (proof of
semantic preservation) of a compiler back-end from Cminor (a simple imperative
intermediate language) to PowerPC assembly code, using the Coq proof assistant
both for programming the compiler and for proving its correctness. Such a
verified compiler is useful in the context of formal methods applied to the
certification of critical software: the verification of the compiler guarantees
that the safety properties proved on the source code hold for the executable
compiled code as well
Molecular excitation in the Interstellar Medium: recent advances in collisional, radiative and chemical processes
We review the different excitation processes in the interstellar mediumComment: Accepted in Chem. Re
Transforming flow information during code optimization for timing analysis
The steadily growing embedded-systems market comprises many application domains in which real-time constraints must be satisfied. To guarantee that these constraints are met, the analysis of the worst-case execution time (WCET) of software components is mandatory. In general WCET analysis needs additional control-flow information, which may be provided manually by the user or calculated automatically by program analysis. For flexibility and simplicity reasons it is desirable to specify the flow information at the same level at which the program is developed, i.e., at the source level. In contrast, to obtain precise WCET bounds the WCET analysis has to be performed at machine-code level. Mapping and transforming the flow information from the source-level down to the machine code, where flow information is used in the WCET analysis, is challenging, even more so if the compiler generates highly optimized code. In this article we present a method for transforming flow information from source code to machine code. To obtain a mapping that is safe and accurate, flow information is transformed in parallel to code transformations performed by an optimizing compiler. This mapping is not only useful for transforming manual code annotations but also if platform-independent flow information is automatically calculated at the source level. We show that our method can be applied to every type of semantics-preserving code transformation. The precision of this flow-information transformation allows its users to calculate tight WCET bounds.Peer reviewe
Transformation of meta-information by abstract Co- interpretation
In this paper we present an approximation method based on abstract interpretation to transform meta-information in parallel with the transformation of concrete data. The meta-information is assumed to describe further properties of the specific data. The construction of a correct transformation function for the meta-information can be quite complicated in case of complex data transformations or data structures. A special approximation method is presented that works with data abstraction.Performing worst-case execution time (WCET) analysis for optimized code is described as a concrete example for the application of this approach. A transformation framework is constructed to correctly update the flow information in case of code transformations
- âŠ