Structured Control Flow Research Articles

Applied static analysis and specialization of cross-core syscalls for multi-core AUTOSAR OS

The development of static real-time control systems often follows a closed-world assumption, allowing extensive RTOS-aware whole-program optimization. For single-core systems, previous work could show the high potential of control-flow-aware static system-call tailoring. However, due to an exponential state explosion in the analysis phase, it cannot simply be extended to a multi-core setting, since the core’s relative timing to each other is undetermined. In this work, we present MultiSSE, a multi-core capable and RTOS-aware static whole-system optimization. First, MultiSSE analyzes the system by determining the relative positions of multiple cores only when necessary. For that, it exploits structural control flow and optionally timing information to handle each core separately as much as possible. Based on the analysis result, a synthesis applies lock elision and system-call optimization to generate specialized multi-core real-time systems for AUTOSAR OS. To enable a static prediction of the run-time reduction, we additionally provide cost models for the optimized cross-core system calls and evaluate the approach with synthetic benchmarks and a real-world quadrotor application. MultiSSE was able to optimize or even completely elide costly cross-core system calls and system objects leading to a reduction of up to 14% of a task’s execution time. In this extended version of a conference publication (Entrup et al. 2023), we provide an advanced description, new cost models, and an end-to-end measurement by developing a synthesis complementing the analysis.

Taking Back Control in an Intermediate Representation for GPU Computing

We describe our experiences successfully applying lightweight formal methods to substantially improve and reformulate an important part of Standard Portable Intermediate Representation SPIRV, an industry-standard language for GPU computing. The formal model that we present has allowed us to (1) identify several ambiguities and needless complexities in the way that structured control flow was defined in the SPIRV specification; (2) interact with the authors of the SPIRV specification to rectify these problems; (3) validate the developer tools and conformance test suites that support the SPIRV language by cross-checking them against our formal model, improving the tools, test suites, and our models in the process; and (4) develop a novel method for fuzzing SPIRV compilers to detect miscompilation bugs that leverages our formal model. The latest release of the SPIRV specification incorporates the revised set of control-flow definitions that have arisen from our work. Furthermore, our novel compiler-fuzzing technique has led to the discovery of twenty distinct, previously unknown bugs in SPIRV compilers from Google, the Khronos Group, Intel, and Mozilla. Our work showcases the practical impact that formal modelling and analysis techniques can have on the design and implementation of industry-standard programming languages.

Beyond Relooper: recursive translation of unstructured control flow to structured control flow (functional pearl)

In many compilers, control flow is represented using an arbitrary directed graph. But in some interesting target languages, including JavaScript and WebAssembly, intraprocedural control flow can be expressed only in structured ways, using loops, conditionals, and multilevel breaks or exits. As was shown by Peterson, Kasami, and Tokura in 1973, such structured control flow can be obtained by translating arbitrary control flow. The translation uses two standard analyses, but as published, it takes three passes—which may explain why it was overlooked by Emscripten, a popular compiler from C to JavaScript. By tweaking the analyses and by applying fundamental ideas from functional programming (recursive functions and immutable abstract-syntax trees), the translation, along with a couple of code improvements, can be implemented in a single pass. This new implementation is slated to be added to the Glasgow Haskell Compiler. Its single-pass translation, its immutable representation, and its use of dominator trees make it much easier to reason about than the original translation.

RVSDG

Intermediate Representations (IRs) are central to optimizing compilers as the way the program is represented may enhance or limit analyses and transformations. Suitable IRs focus on exposing the most relevant information and establish invariants that different compiler passes can rely on. While control-flow centric IRs appear to be a natural fit for imperative programming languages, analyses required by compilers have increasingly shifted to understand data dependencies and work at multiple abstraction layers at the same time. This is partially evidenced in recent developments such as the Multi-Level Intermediate Representation (MLIR) proposed by Google. However, rigorous use of data flow centric IRs in general purpose compilers has not been evaluated for feasibility and usability as previous works provide no practical implementations. We present the Regionalized Value State Dependence Graph (RVSDG) IR for optimizing compilers. The RVSDG is a data flow centric IR where nodes represent computations, edges represent computational dependencies, and regions capture the hierarchical structure of programs. It represents programs in demand-dependence form, implicitly supports structured control flow, and models entire programs within a single IR. We provide a complete specification of the RVSDG, construction and destruction methods, as well as exemplify its utility by presenting Dead Node and Common Node Elimination optimizations. We implemented a prototype compiler and evaluate it in terms of performance, code size, compilation time, and representational overhead. Our results indicate that the RVSDG can serve as a competitive IR in optimizing compilers while reducing complexity.

Modular Programming of Hierarchy and Diversity in Multivariate Polymer/Metal-Organic Framework Hybrid Composites.

The idea that complex systems have a hierarchical arrangement has been widely observed on various scales. In this work, we introduce the concept of modular programming, which emphasizes isolating the functionality of a system into independent, interchangeable modules, to tailor the hierarchy and diversity in these complex systems. Guided by modular programming, a system with multiple compatible components, including modules A, B, C, and so forth, can be constructed and subsequently modified into modules A', B', C', and so forth independently. As a proof of concept, a series of multivariate hierarchical metal-organic frameworks (MOFs) with various compositions, ratios, and distributions were prepared as a compatible system. Sequential click reactions and acid treatments can be utilized to selectively modify a certain modular MOF into a polymer, while other modular MOFs either remain in their original state or dissolve upon treatment. As a result, a series of polymer/MOF composites that traditionally have been viewed as incompatible can be prepared with tailored properties and behaviors. The resulting polymer/MOF hierarchical composites represent a unique porous composite material which contains functional groups and metal clusters with controllable compositions and distribution, tunable hierarchically porous structures, and tailored diversity within one framework. This general synthesis approach guided by modular programming not only provides a facile method to tailor hierarchy and diversity in multivariate systems but also enables the investigation into hierarchy and its structured control flow, which is a critical design feature of future materials for their fast adaptivity and responses to variable environmental conditions.

Relational Program Reasoning Using Compiler IR

Relational program reasoning is concerned with formally comparing pairs of executions of programs. Prominent examples of relational reasoning are program equivalence checking (which considers executions from different programs) and detecting illicit information flow (which considers two executions of the same program). The abstract logical foundations of relational reasoning are, by now, sufficiently well understood. In this paper, we address some of the challenges that remain to make the reasoning practicable. Two major ones are dealing with the feature richness of programming languages such as C and with the weakly structured control flow that many real-world programs exhibit. A popular approach to control this complexity is to define the analyses on the level of an intermediate program representation (IR) such as one generated by modern compilers. In this paper we describe the ideas and insights behind IR-based relational verification. We present a program equivalence checker for C programs that operates on LLVM IR. To extend the reach of the approach and to make it more efficient, we show how dynamic analyses can be employed to support and strengthen the static verification. The effectiveness of the approach is demonstrated by automatically verifying equivalence of functions from different implementations of the standard C library.

Research on Probabilistic Model based Services Composition Compatibility Focusing on Structural Behaviors Modeling

With the increasing of Web services on Internet, services composition requests considering not only the static information compatibility, such as interface grammar and semantic, but also the structural behavior compatibility, i.e., control flow and communication protocol. However, due to the uncertainty of Internet, application failures occurred in service-based software will cause kinds of economic losses. This stochastic phenomenon has been impacted on the structural behavior which makes services composition should take the probabilistic compatibility into account. The probabilistic compatibility needs to compute the degree of compatibility for the effective performance evaluation, which has been an important issue during services collaboration. In this paper, the probabilistic interface automaton is proposed to formalize service behaviors. Then, the synchronized product model is used to the qualitative checking for verifying whether they can interact with each other or not. Third, the probabilistic compatibilities of composite service and component service are discussed for the quantitative computing. Our method provides a reference to generate the correctness and reliable services composition.

Java-to-JavaScript translation via structured control flow reconstruction of compiler IR

We present an approach to cross-compile Java bytecodes to Java-Script, building on existing Java optimizing compiler technology. Static analysis determines which Java classes and methods are reachable. These are then translated to JavaScript using a re-configured Java just-in-time compiler with a new back end that generates JavaScript instead of machine code. Standard compiler optimizations such as method inlining and global value numbering, as well as advanced optimizations such as escape analysis, lead to compact and optimized JavaScript code. Compiler IR is unstructured, so structured control flow needs to be reconstructed before code generation is possible. We present details of our control flow reconstruction algorithm. Our system is based on Graal, an open-source optimizing compiler for the Java HotSpot VM and other VMs. The modular and VM-independent architecture of Graal allows us to reuse the intermediate representation, the bytecode parser, and the high-level optimizations. Our custom back end first performs control flow reconstruction and then JavaScript code generation. The generated JavaScript undergoes a set of optimizations to increase readability and performance. Static analysis is performed on the Graal intermediate representation as well. Benchmark results for medium-sized Java benchmarks such as SPECjbb2005 run with acceptable performance on the V8 JavaScript VM.

Characterization and transformation of unstructured control flow in bulk synchronous GPU applications

In this paper we identify important classes of program control flows in applications targeted to commercially available graphics processing units (GPUs) and characterize their presence in real workloads such as those that occur in CUDA and OpenCL. Broadly, control flow can be characterized as structured or unstructured. It is shown that most existing techniques for handling divergent control in bulk synchronous GPU applications handle structured control flow efficiently, some are incapable of executing unstructured control flow directly, and none handles unstructured control flow efficiently. An approach to reduce the impact of this problem is provided. An unstructured-to-structured control flow transformation for CUDA kernels is implemented and its performance impact on a large class of GPU applications is assessed. The results quantify the importance of improving support for programs with unstructured control flow on GPUs. The transformation can also be used in a JIT compiler pass to execute programs with unstructured control flow on the GPU devices that do not support unstructured control flow. This is an important capability for execution portability of applications using GPU accelerators.

Algorithms and tool support for dynamic information flow analysis

A new approach to dynamic information flow analysis ( DIFA) is presented, and its applications to intrusion detection, software testing and program debugging are discussed. The approach is based on a new forward-computing algorithm that enables online analysis when fast response is not critical. A new forward-computing algorithm for dynamic slicing is also presented, which is more precise than previous forward-computing algorithms and is not restricted to programs with structured control flow. The DIFA and slicing algorithms both rely on a new, precise direct dynamic control dependence algorithm, which requires only constant time per program action. The correctness of this algorithm depends on special, graph-theoretic properties of control dependence, which are established here. A tool called DynFlow is described that implements the proposed approach in order to support analysis of Java byte code programs, and two case studies are presented to illustrate how DynFlow can be used to detect and debug insecure flows. Finally, since dynamic analysis alone is inherently unable to detect implicit information flows, an extension to our approach is described that enables it to detect most implicit information flows at runtime.

Adaptronic Systems for Aerospace Applications (Adaptronische Systeme für Anwendungen in der Luftfahrt)

Summary An overview of different activities related to the application of adaptronics is given, which includes structural health monitoring, shape control and active flow, damping of vibration and noise, and smart skins. Micro aerial vehicles are described as an interesting adaptronics demonstrator platform with aerospace in general being vigorously showing where adaptronics can be applied.

Efficient reversal of the intraprocedural flow of control in adjoint computations

Numerical simulations of physical, chemical, and economical processes play an increasingly important role in modern science and engineering. The implementation of mathematical models of real-world applications on a computer facilitates both the speed and the depth of our understanding of the behavior of the respective systems. Derivative models of the computer programs are required to make the transition from pure simulation to the highly desirable optimization of the numerical models with respect to a potentially very large number of input parameters. Such models can be generated automatically from the given numerical program by a source transformation technique known as automatic differentiation. Reversal of the control flow is especially important for the generation of adjoint derivative models. We describe an approach to the control flow reversal of structured programs motivated by the significant weakness of approaches that do not exploit the result of control-flow analysis. Our approach is used to automatically generate adjoint code for numerical programs by semantic source transformation. After a short introduction to applications and the implementation tool set, we motivate the proposed approach with a simple example. We present a novel preaccumulation algorithm for local Jacobian matrices at the level of basic blocks. The main part of the paper covers the reversal of structured control flow graphs. First we show the algorithmic steps for simple branches and loops. We give a detailed algorithm for the reversal of arbitrary combinations of loops and branches based only on the structural information in a general control flow graph. Dependencies between computations and their enclosing control flow constructs can lead to inefficient adjoint code. We formulate a set of conditions that allows for considerable efficiency gains in the adjoint code while permitting a reasonably simple modification of the reversal algorithms for specially designated control flow subgraphs. We present a sensitivity computation of an oceanographic application that illustrates the benefits of this modified approach.

Transfinite semantics in program slicing

This paper studies mathematically some special kinds of transfinite trace semantics and investigates program slicing w.r.t. these semantics. S everal general facts about slicing, which hold for a wide class of programming languages and their transfinite semantics, are proven. The principal part of the work is done on control flow g raphs keeping the treatment abstracted from any concrete programming language. Structured control flow is not assumed but programs written in standard programming languages with structured control flow are among those to which our theory applies.

Single-pass generation of static single-assignment form for structured languages

Over the last few years, static single assignment (SSA) form has been established as a suitable intermediate program representation that allows new powerful optimizations and simplifies others considerably. Algorithms are known that generate SSA form from programs with an arbitrary flow of control. These algorithms need several passes. We show that it is possible to generate SSA form in a single pass (even during parsing) if the program contains only structured control flow (i.e., no gotos). For such programs the dominator tree can be built on the fly, too. ACM Transactions on Programming Languages and Systems 16(6):1684-1698, November 1994

Program complexity using Hierarchical Abstract Computers

A model of program complexity is introduced which combines structural control flow measures with data flow measures. This complexity measure is based upon the prime program decomposition of a program written for a Hierarchical Abstract Computer. It is shown that this measure is consistent with the ideas of information hiding and data abstraction. Because this measure is sensitive to the linear form of a program, it can be used to measure different concrete representations of the same algorithm, as in a structured and an unstructured version of the same program. Application of the measure as a model of system complexity is given for “upstream” processes (e.g. specification and design phases) where there is no source program to measure by other techniques.

The reduction of branch instruction execution overhead using structured control flow

This paper presents a technique for specifying change of control (e.g. branch) commands at a sequential processor's macroinstruction set level. It is shown that by representing high level language (HLL) control statements with special machine language instructions, the usual delays associated with control flow changes can be reduced. Preserving the HLL control flow information increases performance by reducing both the number of executed branches and pipeline breaks.