UPPAAL-Tiga: Time for Playing Games!

Abstract. We present a general approach to combine symbolic state space representations for the discrete and continuous parts in the synthesis of winning strategies for timed reachability games. The combination is based on abstraction refinement where discrete symbolic techniques are used to produce a sequence of abstract timed game automata. After each refinement step, the resulting abstraction is used for computing an under-and an over-approximation of the timed winning states. The key idea is to identify large relevant and irrelevant parts of the precise weakest winning strategy already on coarse, and therefore simple, abstractions. If neither the existence nor nonexistence of a winning strategy can be established in the approximations, we use them to guide the refinement process. Based on a prototype that combines binary decision diagrams [7,9] and difference bound matrices [5], we experimentally evaluate the technique on standard benchmarks from timed controller synthesis. The results clearly demonstrate the potential of the new approach concerning running time and memory consumption compared to the classical on-the-fly algorithm implemented in Uppaal-Tiga [10,4].

mentioning

confidence: 72%

Combining Symbolic Representations for Solving Timed Games

Ehlers

Mattmüller²,

Peter

2010

“…For example, in the generated chart, it can be seen that Cmd P is blocked more than 5 times during the first cycle, while blocking times for PrimaryF and StsMon P are significantly long only starting from the second cycle. Listing 1.5 shows a chart declaration accepted by Uppaal TIGA [3] which assigns colours for each line (T for task lines, R for resource lines) based on the state (ready, running, blocked or suspended; locked and used, locked and preempted or locked and suspended respectively). Verification and CPU Load Estimates.…”

Section: Resultsmentioning

confidence: 99%

Schedulability Analysis Using Uppaal: Herschel-Planck Case Study

Mikučionis

Larsen

Rasmussen

et al. 2010

Abstract. We propose a modeling framework for performing schedulability analysis by using Uppaal real-time model-checker [2]. The framework is inspired by a case study where schedulability analysis of a satellite system is performed. The framework assumes a single CPU hardware where a fixed priority preemptive scheduler is used in a combination with two resource sharing protocols and in addition voluntary task suspension is considered. The contributions include the modeling framework, its application on an industrial case study and a comparison of results with classical response time analysis.

“…2, consider the action σ1 := m ← InputRead(v) [0,40) in A 1 of a PISEM. Algorithm 1 returns mapLB(σ) and mapU B(σ) with two arrays [1,1] and [2,2], indicated in Figure 2a. Based on the definition of IM, σ 1 should be executed with the temporal precondition that no action in A 2 is executed, satisfying the semantics originally specified in PISEM.…”

Section: Step A1: From Pisem To Immentioning

confidence: 99%

“…Recently there has been an increasing interest in applying games for synthesis, including work by Bloem and Jobstmann et al (the program repair framework [7]), Henzinger and Chatterjee et al (Alpaga and the interface synthesis [3,5]), and David and Larson et al (Uppaal TIGA [2]); these approaches are usually based on non-distributed settings. Our starting model of distributed and timed straight-line programs is based on commonly used paradigms from the real-time community [8].…”

Section: Related Workmentioning

confidence: 99%

Synthesis of Fault-Tolerant Embedded Systems Using Games: From Theory to Practice

Cheng

Rueß

Knoll

et al. 2011

Abstract. In this paper, we present an approach for fault-tolerant synthesis by combining predefined patterns for fault-tolerance with algorithmic game solving. A non-fault-tolerant system, together with the relevant fault hypothesis and faulttolerant mechanism templates in a pool are translated into a distributed game, and we perform an incomplete search of strategies to cope with undecidability. The result of the game is translated back to executable code concretizing fault-tolerant mechanisms using constraint solving. The overall approach is implemented to a prototype tool chain and is illustrated using examples.