{'fraction_non_alphanumeric': 0.04140408369044618, 'fraction_numerical': 0.013549281572977061, 'mean_word_length': 4.432728517630948, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 2, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 1, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
SAW: A Tool for Safety Analysis of Weakly-Hard Systems

We introduce SAW, a tool for safety analysis of weakly-hard systems, in which traditional hard timing constraints are relaxed to allow bounded deadline misses for improving design flexibility and runtime resiliency. Safety verification is a key issue for weakly-hard systems, as it ensures system safety under allowed deadline misses. Previous works are either for linear systems only, or limited to a certain type of nonlinear systems (e.g., systems that satisfy exponential stability and Lipschitz continuity of the system dynamics). In this work, we propose a new technique for infinite-time safety verification of general nonlinear weakly-hard systems. Our approach first discretizes the safe state set into grids and constructs a directed graph, where nodes represent the grids and edges represent the reachability relation. Based on graph theory and dynamic programming, our approach can effectively find the safe initial set (consisting of a set of grids), from which the system can be proven safe under given weakly-hard constraints. Experimental results demonstrate the effectiveness of our approach, when compared with the state-of-the-art. An open source implementation of our tool is available at https://github.com/551100kk/SAW. The virtual machine where the tool is ready to run can be found at https://www.csie.ntu.edu.tw/~r08922054/SAW.ova.


Introduction
Hard timing constraints, where deadlines should always been met, have been widely used in real-time systems to ensure system safety. However, with the rapid increase of system functional and architectural complexity, hard deadlines have become increasingly pessimistic and often lead to infeasible designs or over provisioning of system resources [16,20,21,32]. The concept of weakly-hard systems are thus proposed to relax hard timing constraints by allowing occasional deadline misses [2,11]. This is motivated by the fact that many system functions, such as some control tasks, have certain degrees of robustness and can in fact tolerate some deadline misses, as long as those misses are bounded and dependably controlled. In recent years, considerable efforts have been made in the research of weakly-hard systems, including schedulability analysis [1,2,5,[12][13][14]19,25,28,30], opportunistic control for energy saving [18], control stability analysis and optimization [8,10,22,23,26], and control-schedule co-design under possible deadline misses [3,6,27]. Compared with hard deadlines, weakly-hard constraints can more accurately capture the timing requirements of those system functions that tolerate deadline misses, and significantly improve system feasibility and flexibility [16,20]. Compared with soft deadlines, where any deadline miss is allowed, weakly-hard constraints could still provide deterministic guarantees on system safety, stability, performance, and other properties under formal analysis [17,29]. A common type of weakly-hard model is the (m, K) constraint, which specifies that among any K consecutive task executions, at most m instances could violate their deadlines [2]. Specifically, the high-level structure of a (m, K)constrained weakly-hard system is presented in Fig. 1. Given a sampled-data systemẋ = f (x, u) with a sampling period δ > 0, the system samples the state x at the time t = iδ for n = 0, 1, 2, . . . , and computes the control input u with function π(x). If the computation completes within the given deadline, the system applies u to influence the plant's dynamics. Otherwise, the system stops the computation and applies zero control input. As aforementioned, the system should ensure the control input can be successfully computed and applied within the deadline for at least K−m times over any K consecutive sampling periods.
For such weakly-hard systems, a natural and critical question is whether the system is safe by allowing deadline misses defined in a given (m, K) constraint.
There is only limited prior work in this area, while nominal systems have been adequately studied [4,9,15,31]. In [8], a weakly-hard system with linear dynamic is modeled as a hybrid automaton and then the reachability of the generated hybrid automaton is verified by the tool SpaceEx [9]. In [7], the behavior of a linear weakly-hard system is transformed into a program, and program verification techniques such as abstract interpretation and SMT solvers can be applied.
In our previous work [17], the safety of nonlinear weakly-hard systems are considered for the first time. Our approach tries to derive a safe initial set for any given (m, K) constraint, that is, starting from any initial state within such set, the system will always stay within the same safe state set under the given weaklyhard constraint. Specifically, we first convert the infinite-time safety problem into a finite one by finding a set satisfying both local safety and inductiveness. The computation of such valid set heavily lies on the estimation of the system state evolution, where two key assumptions are made: 1) The system is exponentially stable under nominal cases without any deadline misses, which makes the system state contract with a constant decay rate; 2) The system dynamics are Lipschitz continuous, which helps bound the expansion under a deadline miss. Based on these two assumptions, we can abstract the safety verification problem as a onedimensional problem and use linear programming (LP) to solve it, which we call one-dimension abstraction in the rest of the paper.
In practice, however, the assumptions in [17] are often hard to satisfy and the parameters of exponential stability are difficult to obtain. In addition, while the scalar abstraction provides high efficiency, the experiments demonstrate that the estimation is always over conservative. In this paper, we go one step further and present a new tool SAW for infinite-time safety verification of nonlinear weakly-hard systems without any particular assumption on exponential stability and Lipschitz bound, and try to be less conservative than the scalar abstraction. Formally, the problem solved by this tool is described as follows: Problem 1. Given an (m, K) weakly-hard system with nonlinear dynamicsẋ = f (x, u), sampling period δ, and safe set X, find a safe initial set X 0 , such that from any state x(0) ∈ X 0 , the system will always be inside X.
To solve this problem, we first discretize the safe state set X into grids. We then try to find the grid set that satisfies both local safety and inductiveness. For each property, we build a directed graph, where each node corresponds to a grid and each directed edge represents the mapping between grids with respect to reachability. We will then be able to leverage graph theory to construct the initial safe set. Experimental results demonstrate that our tool is effective for general nonlinear systems.

Algorithms and Tool Design
The schematic diagram of our tool SAW is shown in Fig. 2. The input is a model file that specifies the system dynamics, sampling period, safe region and other parameters, and a configuration file of Flow* [4] (which is set by default but can also be customized). After fed with the input, the tool works as follows (shown in Algorithm 1). The safe state set X is first uniformly partitioned into small d is the dimension of the state space, and p is the number of partitions in each dimension (Line 1 in Algorithm 1). The tool then tries to find the grids that satisfy the local safety. It first invokes a reachability graph constructor to build a one-step reachability graph G 1 to describe how the system evolves in one sampling step (Line 2). Then, a dynamic programming (DP) based approach finds the largest set Γ S = {v s1 , v s2 , . . . , v sn } from which the system will not go out of the safe region. The K-step reachability graph G K is also built in the DP process based on G 1 (Line 3). After that, the tool searches the largest subset Γ I of Γ S that satisfies the inductiveness by using a reverse search algorithm (Line 4). The algorithm outputs Γ I as the target set X 0 (Line 5).
The key functions of the tool are the reachability graph constructor, DPbased local safety set search, and reverse inductiveness set search. In the following sections, we introduce these three functions in detail.

Reachability Graph Construction
Integration in dynamic system equations is often the most time-consuming part to trace the variation of the states. In this function, we use Flow* to get a valid Algorithm 2: Construct one-step graph: constructOneStepGraph() Data: Dynamic system f , grid set Γ , the control law π, sampling period δ Result: Directed graph G1(Γ, E1) /* Initialize the edge set E1 of G1.
overapproximation of reachable set (represented as flowpipes) starting from every grid after a sampling period δ. Given a positive integer n, the graph constructed by the reachability set after n sampling period, n · δ, is called a n-step graph G n . Since the reachability for all the grids in any sampling step is independent under our grid assumption, we first build G 1 and then reuse G 1 to construct G K later without redundant computation of reachable set.
One-step graph is built with Algorithm 2. We consider deadline miss and deadline meet separately, corresponding to two categories of edges (Line 3). For a grid v, if the one-step reachable set R 1 (v) intersects with unsafe state X c , then it is considered as an unsafe grid and we let its reachable grid be ∅. Otherwise, if R 1 (v) intersects with another grid v under the deadline miss/meet event e, then we add a directed edge (v, e, v ) from v to v with label e. The number of outgoing edges for each grid node v is bounded by p d . Assuming that the complexity of Flow* to compute flowpipes for its internal clock is O(1), we can get the overall time complexity as O(|Γ | · p d · δ/ ). K-step graph G K is built for finding the grid set that satisfies local safety and inductiveness. To avoid redundant computation on reachable set, we construct G K based on G 1 by traversing K-length paths, as the bi-product of local safety set searching procedure.

DP-Based Local Safety Set Search
We propose a bottom-up dynamic programming for considering all the possible paths, utilizing the overlapping subproblems property (Algorithm 3). The reachable grid set at step K that is derived from a grid v at step k ≤ K with respect to the number of deadline misses n ≤ m can be defined as DP(v, n, k). To be consistent with Algorithm 2, this set is empty if and only if it does not satisfy the local safety. We need to derive DP(v, 0, 0). Initially, the zero-step reachability is  If there exists an empty set on the right hand side or there is no outgoing edge from v for any e such that n + e ≤ m, we let DP(v, n, k) = ∅. Finally, we have We used bitset to implement the set union which can accelerate 64 times under the 64-bit architecture. The time complexity is O(|Γ | 2 /bits·p d ·K 2 +|Γ | 2 ), where bits depends on the running environment. |Γ | 2 is contributed by G K .

Reverse Inductiveness Set Search
To find the grid set Γ I ⊆ Γ S that satisfies inductiveness, we propose a reverse search algorithm Algorithm 4. Basically, instead of directly searching Γ I , we try to obtain Γ I by removing any grid v within Γ S , from which there exists a path reaching Γ U = Γ − Γ S . Specifically, Algorithm 4 starts with initializing Γ U = Γ − Γ S (line 1). The Γ U iteratively absorbs the grid v that can reach Γ U in K sampling periods, until a fixed point is reached (line 2-3). Finally Γ I = Γ −Γ U is the largest set that satisfies inductiveness. It is implemented as a breadth first search (BFS) on the reversed graph of G K , and the time complexity is O(|Γ | 2 ).

Example Usage
Example 1. Consider the following linear control system from [17]: Then, we run our program with the model file.
To further ease the use of our tool, we also pre-complied our tool for x86 64 linux environment. In such environment, users do not need to compile our tool and can directly invoke saw linux x86 64 instead of saw (which is only available after manually compiling the tool).
The program output is shown in Listing 1.3. Line 6 shows the number of edges of G 1 . Lines 8-10 provide the information of G K , including the number of edges and nodes. Line 12 prints the safe initial set X 0 . Our tool then determines whether the given initial set is safe by checking if it is the subset of X 0 .

Experiments
We implemented a prototype of SAW that is integrated with Flow*. In this section, we first compare our tool with the one-dimension abstraction [17], on the full benchmarks from [17] (#1-#4) and also additional examples with no guarantee on exponential stability from related works (#5 and #6) [24]. Table 1 shows the benchmark settings, including the (m, K) constraint set for each benchmark. Then, we show how different parameter settings affect the verification results of our tool. All our experiments were run on a desktop, with 6-core 3.60 GHz Intel Core i7. Table 2 shows the experimental results. It is worth noting that the one-dimension abstraction cannot find the safe initial set in most cases from [17]. In fact, it only works effectively for a limited set of (m, K), e.g., when no consecutive deadline misses is allowed. For general (m, K) constraints, one-dimension abstraction performs much worse due to the over-conservation. Furthermore, we can see that, without exponential stability, one-dimension abstraction based approach is not applicable for the benchmarks #5 and #6. Note that for benchmark #2, onedimension abstraction obtains a non-empty safe initial set X 0 , which however, does not contain the given initial state set. Thus we use "No" instead of "-" to represent this result. Conversely, for every example, our tool computes a feasible X 0 that contains the initial state set (showing the initial state set is safe), which we denote as "Yes".

Impact of (m, K), Granularity, and Stepsize
(m, K). We take benchmark #1 (Example 1 in Sect. 3) as an example and run our tool under different (m, K) values. Figures 3a, 3b, 3c demonstrate that, for this example, the size of local safety region Γ S shrinks when K gets larger. The size of inductiveness region Γ I grows in contrast. Γ S becomes the same as Γ I when K gets larger, in which case m is the primary parameter that influences the size of Γ I .

Granularity
. We take benchmark #3 as an example, and run our tool with different partition granularities. The results (Figs. 3d, 3e, 3f) show that Γ I grows when p gets larger. The choice of p has significant impact on the result (e.g., the user-defined initial state set cannot be verified when p = 15).
Stepsize. We take benchmark #5 as an example, and run our tool with different stepsizes of Flow*. With the same granularity p = 100, we get the safe initial state set Γ I = [−1.56, 1.32] when step size = 0.1, but Γ I is empty when step size = 0.3. The computation times are 4.713 s and 1.835 s, respectively. Thus, we can see that there is a trade-off between the computational efficiency and the accuracy.

Conclusion
In this paper, we present a new tool SAW to compute a tight estimation of safe initial set for infinite-time safety verification of general nonlinear weakly-hard systems. The tool first discretizes the safe state set into grids. By constructing a reachability graph for the grids based on existing tools, the tool leverages graph theory and dynamic programming technique to compute the safe initial set. We demonstrate that our tool can significantly outperform the state-of-theart one-dimension abstraction approach, and analyze how different constraints and parameters may affect the results of our tool. Future work includes further speedup of the reachability graph construction via parallel computing.