Efficient compilation and execution of synchronous programs via type-state programming

2025-08-02

AI Summary

Synchronous program compilation for safety-critical embedded systems suffers from state-space explosion and poor runtime efficiency. To address this, we propose an automaton-based linear-time compilation method: first, compact finite-state machines (FSMs) are generated via graph rewriting rules; second, these FSMs are encoded as type-safe, compile-time state machines using C++ template metaprogramming. Our approach is the first to deeply integrate graph rewriting with type-state programming, thereby avoiding combinatorial explosion while preserving semantic correctness. Experimental evaluation shows that the generated binaries exhibit comparable size and compilation time to those produced by mainstream tools, while achieving 31–60% average runtime speedup—significantly outperforming existing synchronous language compilers.

Technology Category

• Constraint Satisfaction and Optimization: Satisfiability Modulo Theories
• Natural Language Processing: Code Generation / Program Synthesis from Natural Language
• Machine Learning: Hardware-aware ML

Application Category

• Systems and Infrastructure for Web, Mobile and WoT: Applied ML and AI for Web-based mobile applications
• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Security and Privacy: Large-scale security measurements

Abstract

Synchronous programs are used extensively in implementation of safety critical embedded software. Imperative synchronous programming languages model multiple Finite State Machines (FSMs) executing in lockstep at logical clock ticks. The synchronous view of time along with the FSM based design enables easier formal verification. The synchronous composition of multiple FSMs, during compilation, results in the well known state space explosion problem. Hence, efficiently compiling imperative synchronous programs into small and fast executables is challenging. This paper introduces a novel linear time compilation technique for automata based compilation of synchronous programs. Graph based rewrite rules for kernel programming constructs are introduced. A linear time algorithm applies these rules to produce a FSM. The FSM is then encoded into a type-state program using template meta-programming in C++. Experimental results show that the compilation time and generated binary size is comparable, while the execution times are on average 31-60% faster than current state-of-the-art compilers.

Problem

• Efficient compilation of synchronous programs with state-space explosion
• Linear-time compilation technique for automata-based synchronous programs
• Improving execution speed of compiled synchronous program binaries

Innovation

• Linear time compilation for synchronous programs
• Graph rewrite rules for kernel constructs
• Type-state encoding via C++ templates