Introduction to Model Checking

Transcription

1 Introduction to Model Checking René Thiemann Institute of Computer Science University of Innsbruck WS 2007/2008 RT UIBK) week 4 1/23 Outline Promela - Syntax and Intuitive Meaning Promela - Formal semantics The State-Space Explosion Problem RT UIBK) week 4 2/23

2 Promela - Syntax and Intuitive Meaning nanopromela Promela (Process Meta Language) is modeling language for SPIN most widely used model checker SPIN developed by Gerard Holzmann (Bell Labs, NASA JPL) ACM Software Award 2002 nanopromela is the core of Promela shared variables and channel-based communication formal semantics of a Promela model is a channel system processes are defined by means of a guarded command language No actions, statements describe effect of actions RT UIBK) week 4 4/23 Promela - Syntax and Intuitive Meaning nanopromela nanopromela-program P = [P 1... P n ] with P i processes A process is specified by a statement: stmt ::= skip x := expr c?x c!expr stmt 1 ; stmt 2 atomic{assignments} if :: g 1 stmt 1... :: g n stmt n fi do :: g 1 stmt 1... :: g n stmt n od assignments ::= x 1 := expr 1 ; x 2 := expr 2 ;... ; x m := expr m x is a variable in Var, expr an expression and c a channel, g i a guard assume the Promela specification is type-consistent RT UIBK) week 4 5/23

3 Promela - Syntax and Intuitive Meaning Conditional statements if :: g 1 stmt 1... :: g n stmt n fi Nondeterministic choice between statements stmt i for which g i holds Test-and-set semantics: (deviation from Promela) guard evaluation + selection of enabled command + execution first atomic step of selected statement is all performed atomically The if fi command blocks if no guard holds parallel processes may unblock a process by changing shared variables e.g., when y=0, if :: y > 0 x := 42 fi waits until y exceeds 0 Standard abbreviations: if g then stmt 1 else stmt 2 fi if :: g stmt 1 :: g stmt 2 fi if g then stmt 1 fi if :: g stmt 1 :: g skip fi RT UIBK) week 4 6/23 Promela - Syntax and Intuitive Meaning Iteration statements do :: g 1 stmt 1... :: g n stmt n od Iterative execution of nondeterministic choice among g i stmt i where guard g i holds in the current state No blocking if all guards are violated; instead, loop is aborted do :: g stmt od while g do stmt od No break-statements to abort a loop RT UIBK) week 4 7/23

4 Promela - Syntax and Intuitive Meaning Beverage vending machine The following nanopromela program describes its behaviour: do :: true skip; if :: nsprite > 0 nsprite := nsprite 1 :: nbeer > 0 nbeer := nbeer 1 :: nsprite = nbeer = 0 skip fi :: true atomic{nbeer := max; nsprite := max} od RT UIBK) week 4 8/23 Promela - Syntax and Intuitive Meaning Alternating bit protocol - Receiver c? m, y wait(0) chk msg(0) y = 0 snd ack(0) y = 1 d!1 d!0 y = 0 snd ack(1) y = 1 chk msg(1) wait(1) c? m, y RT UIBK) week 4 9/23

5 Promela - Formal semantics Formal semantics The semantics of a nanopromela-statement over (Var, Chan) is a program graph over (Var, Chan). The program graphs PG 1,..., PG n for the processes P 1,..., P n of a nanopromela-program P = [P 1... P n ] constitute a channel system over (Var, Chan) The locations of the program graph PG i are the sub-statements of the nanopromela-program P i. RT UIBK) week 4 11/23 Promela - Formal semantics Sub-statements For each statement stmt its substatements Sub stmt (stmt) is the smallest set of statements such that RT UIBK) week 4 12/23

6 Promela - Formal semantics Inference rules true: id skip exit where id denotes an action that does not change the values of the variables x := expr true : assign(x, expr) exit assign(x, expr) denotes the action that only changes x, no other variables c?x c?x exit c!expr c!expr exit RT UIBK) week 4 13/23 Promela - Formal semantics Inference rules atomic{x 1 := expr 1 ;... ; x m := expr m } true : α m exit where α 0 = id, α i = Effect(assign(x i, expr i ), Effect(α i 1, η)) for 1 i m RT UIBK) week 4 14/23

7 Promela - Formal semantics Inference rules RT UIBK) week 4 15/23 The State-Space Explosion Problem Sequential programs The # states of a simple program graph is: #program locations variable x dom(x) number of states grows exponentially in the number of program variables N variables with k possible values each yields k N states this is called the state-space explosion problem A program with 10 locations, 3 bools, 4 integers (in range ): = 800, 000 states Adding a single 50-positions bit-array yields 800, states RT UIBK) week 4 17/23

8 The State-Space Explosion Problem Concurrent programs The # states of P P 1... P n is maximally: #states of P 1... #states of P n # states grows exponentially with the number of components The composition of N components of size k each yields k N states This is called the state-space explosion problem RT UIBK) week 4 18/23 The State-Space Explosion Problem Channel systems Asynchronous communication of processes via channels each channel c has a bounded capacity cap(c) if a channel has capacity 0, we obtain handshaking # states of system with N components and K channels is: ( N #program locations i=1 variable x dom(x) ) K dom(c j ) cap(c j ) j=1 this is the underlying structure of Promela RT UIBK) week 4 19/23

9 The State-Space Explosion Problem The alternating bit protocol c! m, 0 d?x snd msg(0) lost st tmr(0) tmr on! wait(0) x = 1 chk ack(0) x = 1 : tmr off! timeout? timeout? x = 0 : tmr off! chk ack(1) x = 0 wait(1) tmr on! st tmr(1) lost snd msg(1) d?x c! m, 1 channel capacity 10, and datums are bits, yields 2 }{{} 8 2 }{{} 6 2 }{{} 4 10 }{{} 2 10 = states sender recv c d }{{} timer RT UIBK) week 4 20/23 The State-Space Explosion Problem The Need for Automated Verification requirements system Formalizing Modeling property specification system model huge! Model Checking satisfied violated + counterexample insufficient memory RT UIBK) week 4 21/23

10 The State-Space Explosion Problem Summary of Modeling Concurrent Systems Transition systems are fundamental for modeling software Interleaving = execution of independent concurrent processes by nondeterminism Channel systems = program graphs + first-in first-out communication channels handshaking for channels of capacity 0 asynchronous message passing when capacity exceeds 0 semantical model of Promela Formal semantic for Promela know exactly which system is verified Size of transition systems grows exponentially in the number of concurrent components and the number of variables RT UIBK) week 4 22/23 The State-Space Explosion Problem Exercises Write promela-code for the timer and the sender of the alternating bit protocol. Construct the corresponding program graphs according to the formal semantics. Change the inference rules such that conditional- and iteration-statements require one step for choosing the case without partially evaluating the corresponding statement. (Note that this refinement corresponds to the semantics of full Promela.) RT UIBK) week 4 23/23