Control-Flow-Driven Source Level Timing Annotation for Embedded Software Models on Transaction Level

2011 ◽  
Author(s):  
Daniel Mueller-Gritschneder ◽  
Kun Lu ◽  
Ulf Schlichtmann
Keyword(s):  
Embedded Software ◽  
Control Flow ◽  
Software Models ◽  
Source Level ◽  
Transaction Level

scholarly journals Reconciling optimization with secure compilation

2021 ◽  
Vol 5 (OOPSLA) ◽  
pp. 1-30
Author(s):  
Son Tuan Vu ◽  
Albert Cohen ◽  
Arnaud De Grandmaison ◽  
Christophe Guillon ◽  
Karine Heydemann
Keyword(s):  
Side Effects ◽  
Control Flow ◽  
Partial Ordering ◽  
Input Output ◽  
Machine Code ◽  
Fine Grained ◽  
Control Flow Integrity ◽  
Correct Execution ◽  
Source Level ◽  
And Performance

Software protections against side-channel and physical attacks are essential to the development of secure applications. Such protections are meaningful at machine code or micro-architectural level, but they typically do not carry observable semantics at source level. This renders them susceptible to miscompilation, and security engineers embed input/output side-effects to prevent optimizing compilers from altering them. Yet these side-effects are error-prone and compiler-dependent. The current practice involves analyzing the generated machine code to make sure security or privacy properties are still enforced. These side-effects may also be too expensive in fine-grained protections such as control-flow integrity. We introduce observations of the program state that are intrinsic to the correct execution of security protections, along with means to specify and preserve observations across the compilation flow. Such observations complement the input/output semantics-preservation contract of compilers. We introduce an opacification mechanism to preserve and enforce a partial ordering of observations. This approach is compatible with a production compiler and does not incur any modification to its optimization passes. We validate the effectiveness and performance of our approach on a range of benchmarks, expressing the secure compilation of these applications in terms of observations to be made at specific program points.

Developing platform specific model for MPSoC architecture from UML-based embedded software models

2009 ◽  
Vol 82 (10) ◽  
pp. 1695-1708 ◽  
Author(s):  
Sang-Uk Jeon ◽  
Jang-Eui Hong ◽  
In-Gwon Song ◽  
Doo-Hwan Bae
Keyword(s):  
Embedded Software ◽  
Specific Model ◽  
Software Models ◽  
Developing Platform

scholarly journals Scenario-Aware Program Specialization for Timing Predictability

2021 ◽  
Vol 18 (4) ◽  
pp. 1-26
Author(s):  
Joscha Benz ◽  
Oliver Bringmann
Keyword(s):  
Program Analysis ◽  
Control Flow ◽  
Wcet Analysis ◽  
Specific System ◽  
Worst Case ◽  
Program Specialization ◽  
Operating Modes ◽  
Source Level ◽  
Dependent Flow ◽  
Timing Simulation

The successful application of static program analysis strongly depends on flow facts of a program such as loop bounds, control-flow constraints, and operating modes. This problem heavily affects the design of real-time systems, since static program analyses are a prerequisite to determine the timing behavior of a program. For example, this becomes obvious in worst-case execution time (WCET) analysis, which is often infeasible without user-annotated flow facts. Moreover, many timing simulation approaches use statically derived timings of partial program paths to reduce simulation overhead. Annotating flow facts on binary or source level is either error-prone and tedious, or requires specialized compilers that can transform source-level annotations along with the program during optimization. To overcome these obstacles, so-called scenarios can be used. Scenarios are a design-time methodology that describe a set of possible system parameters, such as image resolutions, operating modes, or application-dependent flow facts. The information described by a scenario is unknown in general but known and constant for a specific system. In this article, 1 we present a methodology for scenario-aware program specialization to improve timing predictability. Moreover, we provide an implementation of this methodology for embedded software written in C/C++. We show the effectiveness of our approach by evaluating its impact on WCET analysis using almost all of TACLeBench–achieving an average reduction of WCET of 31%. In addition, we provide a thorough qualitative and evaluation-based comparison to closely related work, as well as two case studies.

scholarly journals A Precise Framework for Source-Level Control-Flow Analysis

2021 ◽  
Author(s):  
Idriss Riouak ◽  
Christoph Reichenbach ◽  
Gorel Hedin ◽  
Niklas Fors
Keyword(s):  
Flow Analysis ◽  
Control Flow ◽  
Level Control ◽  
Source Level ◽  
Control Flow Analysis

scholarly journals SCCharts - Language and Interactive Incremental Compilation

2017 ◽  
Author(s):  
Christian Motika
Keyword(s):  
Nuclear Power ◽  
Power Plants ◽  
Reactive Systems ◽  
Control Flow ◽  
Model Transformations ◽  
Critical Systems ◽  
Safety Critical ◽  
Incremental Model ◽  
Software Models ◽  
Safety Critical Systems

Safety-critical systems are a subclass of reactive systems, a dominating class of computer systems these days. Such systems control the airbags in our cars, the flaps of an aircraft, nuclear power plants or pace makers. Software for these systems must be reliable. Hence, a language and tooling is needed that allows to build and maintain reliable software models. Furthermore, a reliable compiler is required to obtain decent machine-understandable and executable code from highly abstract models. This thesis presents SCCharts, a Statecharts-based synchronous and visual modeling language for specifying and designing safety-critical systems and for deriving their implementations. It elaborates on why a control-flow oriented and synchronous language is desirable and how incremental language features are chosen to flatten learning curve. It presents an interactive incremental model transformation based compilation approach termed SLIC. It shows how SLIC helps in supporting both, the modeler and the tool smith for building reliable models and maintaining a reliable compiler, respectively. A SLIC-based compiler for SCCharts including its high-level model transformations is presented. Furthermore, practicality aspects of the KIELER SCCharts language and tooling implementation complete the considerations to validate the proposed approach.

Sign in / Sign up

Export Citation Format

Share Document