www.prismmodelchecker.org

IEEE 802.11 Wireless LAN

Contents

Related publications: [KNS02a]

Introduction

This case study concerns probabilistic model checking of certain aspects of the IEEE 802.11 Wireless LAN. The international standard IEEE 802.11 was developed recently in recognition of the increased demand for wireless local area networks which permit interoperability of heterogeneous communication devices. In contrast to wired devices, stations of a wireless network cannot listen to their own transmission, and are therefore unable to employ medium access control schemes such as Carrier Sense Multiple Access with Collision Detection (CSMA/CD) in order to prevent simultaneous transmission on the channel. Instead, the IEEE 802.11 standard describes a Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) mechanism, using a randomised exponential backoff rule to minimise the likelihood of transmission collision.

We model a two-way handshake mechanism of the IEEE 802.11 medium access control scheme, operating in a fixed network topology, using the modelling formalism of probabilistic timed automata. This formalism allows both nondeterministic choice (which, for example, can be used to model the unspecified data packet length) and probabilistic choice (which, for example, is present in the randomised backoff procedure) to coexist in the same model.

Probabilistic Timed Automata Model

We consider a probabilistic timed automata model WLAN of the IEEE 802.11 Wireless LAN which models two stations colliding - trying to send messages at the same time - and then entering the randomised exponential backoff procedure. The timing constraints of the model correspond to the Frequency Hopping Spread Spectrum (FHSS) physical layer, rounded by a factor of 50 (i.e. 1 time unit equals 50 μs) to reduce complexity. We constructed an MDP of the model using the integer semantics given in [KNS02a].

The mode consists of three components operating in parallel, namely chan (the channel) and sender_i for i=1,2 (the sending stations).

The channel

The probabilistic timed automaton representing the channel is shown in below. This automaton has two variables c1 and c2 which record the status of the packet being sent by station 1 and station 2 respectively, and which are updated both when a station starts sending a packet (event send) and when a station finishes sending a packet (event finish). These variables have the following interpretation: ci=0 - nothing being sent by station i; ci=1 - packet from station i being sent correctly; ci=2 - packet from station i being sent garbled.

timed automaton representing the channel

The sending stations

The probabilistic timed automaton sender_1 representing station 1 is shown below and the automaton for station 2 is symmetric. The sender begins in SENSE with a data packet ready to send, and senses the channel. If the channel remains free for DIFS, then the sender enters its vulnerable period and starts sending a packet (event send), otherwise the station enters backoff via an urgent transition. The time taken to send a packet is nondeterministic (within TTMIN and TTMAX). The success of the transmission depends on whether a collision has occurred, and is recorded by setting the variable status to the value of the channel variable c1. The sender then immediately tests the channel (represented by the urgent location TESTC). If the channel is busy, the sender enters the backoff procedure, otherwise it waits for an acknowledgement. If the packet was sent correctly (status=1), then the destination station waits for SIFS and sends the acknowledgement; the sending station then receives this acknowledgement and finishes. On the other hand, if the packet was not sent correctly (status=2), then the destination station does nothing. In this case, the sender times-out and enters the backoff procedure.

In the backoff procedure, the sender first waits for the channel to be free for DIFS and then sets its backoff value according to the random assignment backoff:=RAND(bc) The automaton then decrements backoff by 1 if the channel remains free for ASLOT. However, if the channel is sensed busy within this slot, it waits until the channel becomes free and then waits for DIFS before resuming its backoff procedure. When the value of backoff reaches 0 the sender starts re-sending its data packet.

timed automaton representing a station

Parameters

We use the parameters of the Frequency Hopping Spread Spectrum (FHSS) physical layer, with a transmission bit rate of 2Mbps for the data payload, as given below.

variable descriptionvalue
ASLOT ength of each backoff slot 50μs
CCA time receiver needs to asses the medium 27μs
Turnaroundtime a station needs to change from receiving to sending20μs
SIFS short interframe space 28μs
DIFS DCF interframe space 128μs
TT_MIN minimum time to send a packet 224μs
TT_MAX maximum time to send a packet 15,717μs
ACK time to send an acknowledgement 205μs
ACK_TO time sender waits for acknowledgement before timing-out 300μs
AIRPROP the air propagation time 1μs
VULN vulnerable period (AIRPROP+CCA+Turnaround) 48μs

PRISM model

The PRISM source code for this model is given below.

// WLAN PROTOCOL (two stations)
// discrete time model
// gxn/jzs 20/02/02

mdp

// TIMING CONSTRAINTS
// we have used the FHSS parameters
// then scaled by the value of ASLOTTIME
const int ASLOTTIME = 1;
const int DIFS = 3; // due to scaling can be non-deterministically either 2 or 3
const int VULN = 1; // due to scaling can be non-deterministically either 0 or 1
const int TRANS_TIME_MAX = 315; // scaling up
const int TRANS_TIME_MIN = 4; // scaling down
const int ACK_TO = 6; 
const int ACK = 4; // due to scaling can be non-deterministically either 3 or 4
const int SIFS = 1; // due to scaling can be non-deterministically either 0 or 1
const int TIME_MAX = 315; // maximum constant used in timing constraints + 1
const int BOFF = 6; // max backoff (since contention window is [15,1023])

// THE MEDIUM/CHANNEL

formula busy = c1>0 | c2>0; // channel is busy
formula free = c1=0 & c2=0; // channel is free

module medium
	
	col : [0..8]; // number of collisions
	// medium status 
	c1 : [0..2];
	c2 : [0..2];
	// ci corresponds to messages associated with station i
	// 0 nothing being sent
	// 1 being sent correctly
	// 2 being sent garbled	  
	
	// begin sending message and nothing else currently being sent
	[send1] c1=0 & c2=0 -> (c1'=1);
	[send2] c2=0 & c1=0 -> (c2'=1);
	// begin sending message and  something is already being sent
	// in this case both messages become garbled
	[send1] c1=0 & c2>0 -> (c1'=2) & (c2'=2) & col'=min(col+1,8);
	[send2] c2=0 & c1>0 -> (c1'=2) & (c2'=2) & col'=min(col+1,8);
	// finish sending message
	[finish1] c1>0 -> (c1'=0);
	[finish2] c2>0 -> (c2'=0);
	
endmodule

// STATION 1
module station1
	// clock for station 1
	x1 : [0..TIME_MAX];
	
	// local state
	s1 : [1..12];
	// 1 sense
	// 2 wait until free before setting backoff
	// 3 wait for DIFS then set slot
	// 4 set backoff 
	// 5 backoff
	// 6 wait until free in backoff
	// 7 wait for DIFS then resume backoff
	// 8 vulnerable 
	// 9 transmit
	// 11 wait for SIFS and then ACK
	// 10 wait for ACT_TO 
	// 12 done
	// BACKOFF
	// separate into slots
	slot1 : [0..63]; 
	backoff1 : [0..15];
	
	// BACKOFF COUNTER
	bc1 : [0..BOFF];
	// SENSE
	// let time pass
	[time] s1=1 & x1<DIFS & free -> (x1'=min(x1+1,TIME_MAX));
	// ready to transmit
	[] s1=1 & (x1=DIFS | x1=DIFS-1) -> (s1'=8) & (x1'=0);
	// found channel busy so wait until free
	[] s1=1 & busy -> (s1'=2) & (x1'=0);
	// WAIT UNTIL FREE BEFORE SETTING BACKOFF
	// let time pass (no need for the clock x1 to change)
	[time] s1=2 & busy -> (s1'=2);
	// find that channel is free so check its free for DIFS before setting backoff
	[] s1=2 & free -> (s1'=3);
	// WAIT FOR DIFS THEN SET BACKOFF
	// let time pass
	[time] s1=3 & x1<DIFS & free -> (x1'=min(x1+1,TIME_MAX));
	// found channel busy so wait until free
	[] s1=3 & busy -> (s1'=2) & (x1'=0);
	// start backoff  first uniformly choose slot
	// backoff counter 0
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=0 ->
		   (s1'=4) & (x1'=0) & (slot1'=0) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 1
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=1 ->
		   1/2 : (s1'=4) & (x1'=0) & (slot1'=0) & (bc1'=min(bc1+1,BOFF))
		+ 1/2 : (s1'=4) & (x1'=0) & (slot1'=1) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 2
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=2 ->
		   1/4 : (s1'=4) & (x1'=0) & (slot1'=0) & (bc1'=min(bc1+1,BOFF))
		+ 1/4 : (s1'=4) & (x1'=0) & (slot1'=1) & (bc1'=min(bc1+1,BOFF))
		+ 1/4 : (s1'=4) & (x1'=0) & (slot1'=2) & (bc1'=min(bc1+1,BOFF))
		+ 1/4 : (s1'=4) & (x1'=0) & (slot1'=3) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 3
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=3 ->
		   1/8 : (s1'=4) & (x1'=0) & (slot1'=0) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=1) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=2) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=3) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=4) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=5) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=6) & (bc1'=min(bc1+1,BOFF))
		+ 1/8 : (s1'=4) & (x1'=0) & (slot1'=7) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 4
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=4 ->
		   1/16 : (s1'=4) & (x1'=0) & (slot1'=0 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=1 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=2 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=3 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=4 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=5 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=6 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=7 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=8 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=9 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=10) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=11) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=12) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=13) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=14) & (bc1'=min(bc1+1,BOFF))
		+ 1/16 : (s1'=4) & (x1'=0) & (slot1'=15) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 5
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=5 ->
		   1/32 : (s1'=4) & (x1'=0) & (slot1'=0 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=1 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=2 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=3 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=4 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=5 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=6 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=7 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=8 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=9 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=10) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=11) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=12) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=13) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=14) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=15) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=16) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=17) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=18) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=19) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=20) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=21) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=22) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=23) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=24) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=25) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=26) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=27) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=28) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=29) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=30) & (bc1'=min(bc1+1,BOFF))
		+ 1/32 : (s1'=4) & (x1'=0) & (slot1'=31) & (bc1'=min(bc1+1,BOFF));
	// backoff counter 6
	[] s1=3 & (x1=DIFS | x1=DIFS-1) & bc1=6 ->
		   1/64 : (s1'=4) & (x1'=0) & (slot1'=0 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=1 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=2 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=3 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=4 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=5 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=6 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=7 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=8 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=9 ) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=10) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=11) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=12) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=13) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=14) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=15) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=16) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=17) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=18) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=19) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=20) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=21) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=22) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=23) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=24) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=25) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=26) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=27) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=28) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=29) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=30) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=31) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=32) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=33) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=34) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=35) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=36) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=37) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=38) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=39) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=40) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=41) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=42) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=43) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=44) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=45) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=46) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=47) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=48) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=49) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=50) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=51) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=52) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=53) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=54) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=55) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=56) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=57) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=58) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=59) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=60) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=61) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=62) & (bc1'=min(bc1+1,BOFF))
		+ 1/64 : (s1'=4) & (x1'=0) & (slot1'=63) & (bc1'=min(bc1+1,BOFF));
	// SET BACKOFF (no time can pass)
	// chosen slot now set backoff
	[] s1=4 -> 1/16 : (s1'=5) & (backoff1'=0)
		    + 1/16 : (s1'=5) & (backoff1'=1)
		    + 1/16 : (s1'=5) & (backoff1'=2)
		    + 1/16 : (s1'=5) & (backoff1'=3)
		    + 1/16 : (s1'=5) & (backoff1'=4)
		    + 1/16 : (s1'=5) & (backoff1'=5)
		    + 1/16 : (s1'=5) & (backoff1'=6)
		    + 1/16 : (s1'=5) & (backoff1'=7)
		    + 1/16 : (s1'=5) & (backoff1'=8)
		    + 1/16 : (s1'=5) & (backoff1'=9)
		    + 1/16 : (s1'=5) & (backoff1'=10)
		    + 1/16 : (s1'=5) & (backoff1'=11)
		    + 1/16 : (s1'=5) & (backoff1'=12)
		    + 1/16 : (s1'=5) & (backoff1'=13)
		    + 1/16 : (s1'=5) & (backoff1'=14)
		    + 1/16 : (s1'=5) & (backoff1'=15);
	// BACKOFF
	// let time pass
	[time] s1=5 & x1<ASLOTTIME & free -> (x1'=min(x1+1,TIME_MAX));
	// decrement backoff
	[] s1=5 & x1=ASLOTTIME & backoff1>0 -> (s1'=5) & (x1'=0) & (backoff1'=backoff1-1);	
	[] s1=5 & x1=ASLOTTIME & backoff1=0 & slot1>0 ->
			(s1'=5) & (x1'=0) & (backoff1'=15) & (slot1'=slot1-1);	
	// finish backoff 
	[] s1=5 & x1=ASLOTTIME & backoff1=0 & slot1=0 -> (s1'=8) & (x1'=0);
	// found channel busy
	[] s1=5 & busy -> (s1'=6) & (x1'=0);
	// WAIT UNTIL FREE IN BACKOFF
	// let time pass (no need for the clock x1 to change)
	[time] s1=6 & busy -> (s1'=6);
	// find that channel is free
	[] s1=6 & free -> (s1'=7);
	
	// WAIT FOR DIFS THEN RESUME BACKOFF
	// let time pass
	[time] s1=7 & x1<DIFS & free -> (x1'=min(x1+1,TIME_MAX));
	// resume backoff (start again from previous backoff)
	[] s1=7 & (x1=DIFS | x1=DIFS-1) -> (s1'=5) & (x1'=0);
	// found channel busy
	[] s1=7 & busy -> (s1'=6) & (x1'=0);
	
	// VULNERABLE
	// let time pass
	[time] s1=8 & x1<VULN -> (x1'=min(x1+1,TIME_MAX));
	// move to transmit
	[send1] s1=8 & (x1=VULN | x1=VULN-1) -> (s1'=9) & (x1'=0);
	// TRANSMIT
	// let time pass
	[time] s1=9 & x1<TRANS_TIME_MAX -> (x1'=min(x1+1,TIME_MAX));
	// finish transmission successful	
	[finish1] s1=9 & x1>=TRANS_TIME_MIN & c1=1 -> (s1'=10) & (x1'=0);
	// finish transmission garbled
	[finish1] s1=9 & x1>=TRANS_TIME_MIN & c1=2 -> (s1'=11) & (x1'=0);
	// WAIT FOR SIFS THEN WAIT FOR ACK
	
	// WAIT FOR SIFS i.e. c1=0
	// check channel and busy: go into backoff
	[] s1=10 & c1=0 & x1=0 & busy -> (s1'=2);
	// chack channel and free: let time pass
	[time] s1=10 & c1=0 & x1=0 & free -> (x1'=min(x1+1,TIME_MAX));
	// let time pass
	[time] s1=10 & c1=0 & x1>0 & x1<SIFS -> (x1'=min(x1+1,TIME_MAX));
	// ack is sent after SIFS (since SIFS-1=0 add condition that channel is free)
	[send1] s1=10 & c1=0 & (x1=SIFS | (x1=SIFS-1 & free)) -> (s1'=10) & (x1'=0);
	
	// WAIT FOR ACK i.e. c1=1
	// let time pass
	[time] s1=10 & c1=1 & x1<ACK -> (x1'=min(x1+1,TIME_MAX));
	// get acknowledgement so packet sent correctly and move to done
	[finish1] s1=10 & c1=1 & (x1=ACK | x1=ACK-1) -> (s1'=12) & (x1'=0) & (bc1'=0);
	
	// WAIT FOR ACK_TO
	// check channel and busy: go into backoff
	[] s1=11 & x1=0 & busy -> (s1'=2);
	// check channel and free: let time pass
	[time] s1=11 & x1=0 & free -> (x1'=min(x1+1,TIME_MAX));
	// let time pass
	[time] s1=11 & x1>0 & x1<ACK_TO -> (x1'=min(x1+1,TIME_MAX));
	// no acknowledgement (go to backoff waiting DIFS first)
	[] s1=11 & x1=ACK_TO -> (s1'=3) & (x1'=0);
		
	// DONE
	[time] s1=12 -> (s1'=12);
	
endmodule

// STATION 2 (rename STATION 1)
module station2=station1[x1=x2, 
                  s1=s2,
                  s2=s1,
                  c1=c2,
                  c2=c1, 
                  slot1=slot2, 
                  backoff1=backoff2, 
                  bc1=bc2, 
                  send1=send2, 
                  finish1=finish2] 
endmodule

// reward structure for expected number of collisions
rewards "collisions"
	[send1] c1=0 & c2>0 : 1; // station one starts transmitting and station two is already transmitting
	[send2] c2=0 & c1>0 : 1; // station two starts transmitting and station one is already transmitting
endrewards

// reward structure for expected time
// recall one time unit equals ASLOT(=50μs)
rewards "time"
	[time] true : 50;
endrewards

// reward strcuture for expected cost
// cost (per time unit) is set to:
// 1 in locations where the channel is free,
// 10 in locations where the channel is in use and a message is being sent correctly
// 1000 in locations where a station is sending a garbled message
// 2000 in locations where both stations are sending garbled messages
rewards	"cost"
	[time] c1=0 & c2=0 : 50;
	[time] c1=1 & c2=0 : 50*10;
	[time] c1=0 & c2=1 : 50*10;
	[time] c1=1 & c2=1 : 50*20;
	[time] c1=0 & c2=2 & bc1=0 & bc2=0 : 50*10;
	[time] c1=2 & c2=0 & bc1=0 & bc2=0 : 50*10;
	[time] c1=2 & c2=2 & bc1=0 & bc2=0 : 50*20;
	[time] c1=0 & c2=2 & (bc1>0 | bc2>0) : 50*1000;
	[time] c1=2 & c2=0 & (bc1>0 | bc2>0) : 50*1000;
	[time] c1=2 & c2=2 & (bc1>0 | bc2>0) : 50*2000;
endrewards
View: printable version          Download: wlan.nm

When checking probabilistic reachability and expected reachability properties we vary the value of bcmax (the maximum value a station's backoff counter can take) from 0 up to 6. A station increases its backoff counter (up to the value of bcmax) each time a collision occurs and that the value of the backoff counter influences the range over which its next backoff is chosen. More precisely, a station's chooses its next backoff value uniformly from the range {0,1,..., 2(k+4-1)} when its backoff counter equals k.

When checking deadline properties (by adding an extra clock to the model and preventing progress once the clock reaches a certain deadline) we consider different values of TT_MAX, in particular the values 500, 1,250 and 2,500 (again rounding by a factor of 50 to reduce complexity).

For details on the correctness of the integer semantics when verifying probabilistic timed automata against performance measures see [KNPS06].

Model Statistics

The tables below shows statistics for each model we have built. The first section gives the number of states in the MDP representing the model. The second part refers to the MTBDD which represents this MDP: the total number of nodes and the number of leaves (terminal nodes).

bcmax:   States: Nodes: Leaves:
016,069 31,540 3
134,855 39,436 4
287,345 54,130 5
3217,082 64,756 6
4586,255 81,684 6
51,774,06892,744 7
65,958,233105,8768

Deadline Models:

TT_MAX=500
DEADLINE (μs):   States: Nodes: Leaves:
2,500 478,881 65,797 6
5,000 71,521,898 153,0328
10,000569,487,340267,9618

TT_MAX=1,250
DEADLINE (μs):   States: Nodes: Leaves:
2,500 534,850 71,822 6
5,000 72,262,456 176,9328
10,000575,779,335361,6758

TT_MAX=2,500
DEADLINE (μs):   States: Nodes: Leaves:
2,500 557,141 82,459 6
5,000 72,676,168 216,9718
10,000583,661,380415,0078

Model Construction Times

The tables below gives the times taken to construct the models. There are two stages. Firstly, the system description (in our module based language) is parsed and converted to the MTBDD representing it. Secondly, reachability is performed to identify non-reachable states and the MTBDD is filtered accordingly. Reachability is performed using a BDD based fixpoint algorithm. The number of iterations for this process is also given.

bcmax:   Construction:   Reachability:
Time (s): Iter.s: Time per iter. (s):
08.393460.0186
111.83710.0268
217.43960.0380
323.04210.0493
429.04460.0583
535.84710.0681
644.34960.0794

Deadline Models:

TT_MAX=500
DEADLINE (μs): Construction:   Reachability:
Time (s): Iter.s: Time per iter. (s):
2,500 11.81000.104
5,000 61.22220.253
10,000243 4770.481

TT_MAX=1,250
DEADLINE (μs): Construction:   Reachability:
Time (s): Iter.s: Time per iter. (s):
2,500 13.4 990.121
5,000 72.91960.339
10,000472 4171.03

TT_MAX=2,500
DEADLINE (μs): Construction:   Reachability:
Time (s): Iter.s: Time per iter. (s):
2,500 16.8 990.153
5,000 94.91960.459
10,000482 3221.41

Analysis results

We now report on the model checking results obtained using PRISM when considering a number of different parameters. We consider three different types performance measures:

Due to the size of the deadline models, all experiments on these models were performed with PRISM's MTBDD engine.

  • Probabilistic reachability: The following probabilistic reachability properties have been verified.

    • "With probability 1, eventually both stations have sent their packet correctly." In PCTL this is expressed by:

      P>=1 [ true U s1=12 & s2=12 ].

      Model checking times:

      bcmax:   Iterations: Time per iter. (s):
      01,0490.0158
      11,0970.0237
      21,1930.0378
      31,3850.0669
      41,7690.1295
      52,5370.2184
      64,0730.3602

      Conclusion: the property holds in the initial state.
    • "The maximum probability that either station's backoff counter reaches k." To verify this property we add an extra variable to the model which counts the number of collisions, and then find the maximum probability of this variable reaching k. In PRISM this is expressed by:

      Pmax=? [ true U bc1=k | bc2=k ]

      Model checking times:

      bcmax:   k=2k=4k=6k=8
      iters: time per
      iter (s):
      iters: time per
      iter (s):
      iters: time per
      iter (s):
      iters: time per
      iter (s):
      0280.03531700.23483080.5483436 0.0353
      1280.03782180.31884470.7781658 0.0378
      2280.04252180.37706361.21971,0190.0425
      3280.04892180.43408252.16541,5960.0489
      4280.05282180.47488252.09592,3130.0528
      5280.05712180.51468252.23313,0220.0571
      6280.05852180.50378252.24943,0220.0585

      Model checking results:

      bcmax:   k=2k=3k=4k=5k=6k=7k=8
      00.1835940.0337070.0061880.0011360.0002090.0000387.03e-6
      10.1835940.0170330.0015800.0001470.0000141.26e-6 1.17e-7
      20.1835940.0170330.0007940.0000371.73e-6 8.05e-8 3.75e-9
      30.1835940.0170330.0007940.0000194.34e-7 1.01e-8 2.37e-10
      40.1835940.0170330.0007940.0000192.17e-7 2.54e-9 2.98e-11
      50.1835940.0170330.0007940.0000192.17e-7 1.27e-9 7.45e-12
      60.1835940.0170330.0007940.0000192.17e-7 1.27e-9 3.72e-12
    • Time-bounded probabilistic reachability: for the deadline models the following properties are verified:

      • P1 - the minimum probability of both stations correctly delivering their packets within time T;
      • P2 - the minimum probability of either station correctly delivering its packet within time T;
      • P3 - the minimum probability of station 1 correctly delivering its packet within time T.

      In PCTL these is expressed by:

      	Pmin=? [ true U s1=12 & s2=12 & t<=T ]
      
      	Pmin=? [ true U (s1=12 | s2=12) & t<=T ]
      
      	Pmin=? [ true U s1=12 & t<=T ]
      

      Model checking times:

      TT_MAX=500
      DEADLINE (μs):   Iterations:   Time per iter. (s):
      P1 P2 P3 P1 P2 P3
      2,500 73 92 89 0.0610.1660.115
      5,000 1872152151.06 1.44 1.78
      10,00044546546912.6 10.4 11.7

      TT_MAX=1,250
      DEADLINE (μs):   Iterations:   Time per iter. (s):
      P1 P2 P3 P1 P2 P3
      2,500 59 71 710.0440.0600.051
      5,000 1421641700.2850.6500.596
      10,0003584054108.44 8.54 8.79

      TT_MAX=2,500
      DEADLINE (μs):   Iterations:   Time per iter. (s):
      P1 P2 P3 P1 P2 P3
      2,500 8 10 10 0.0470.0720.052
      5,000 1081321320.0930.2390.160
      10,0002273543543.02 3.212.77

      Model checking results: in the graph below, for a selection of different values for DEADLINE, we have plotted the model checking results for each value of TT_MAX.

      • TT_MAX=500

        graph for deadline properties when TT_MAX=500
      • TT_MAX=1,250

        graph for deadline properties when TT_MAX=1,250
      • TT_MAX=2,500

        graph for deadline properties when TT_MAX=2,500
    • Expected reachability: based on the reward structures given in the PRISM source code we consider the following expected reachability properties.

      • Maximum expected number of collisions before both stations correctly send their packets (R{"collisions"}max=? [ F s1=12 & s2=12 ])

        Model checking times and results:

        bcmax:   Iterations: Time per iter. (s):   Max expected collisions:
        0340 0.00351.2248
        1422 0.00871.2023
        2616 0.02811.2014
        310000.08071.2014
        415650.20051.2014
        531010.54031.2014
        661691.82121.2014
      • Maximum expected time until both stations correctly deliver their packets (R{"time"}max=? [ F s1=12 & s2=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        0996 0.00093,743 0.0032
        11,0170.00263,130 0.0085
        21,2640.00973,019 0.0270
        31,8530.04203,398 0.0709
        43,0890.13124,390 0.1818
        55,4420.43986,813 0.4985
        69,3851.594910,8481.6467

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 3,792 3,865 3,882 3,883 3,883 3,883 3,883
        1,250 6,206 6,263 6,280 6,281 6,281 6,281 6,281
        2,500 10,23010,26110,27610,27710,27710,27710,277
        5,000 18,27818,25518,26818,27018,27018,27018,270
        10,00034,40134,26534,27434,27534,27534,27534,275
        15,00050,52150,27150,27550,27950,28150,28150,281
        15,80052,94452,67752,68152,68252,68252,68252,682
      • Maximum expected cost until both stations correctly deliver their packets (R{"cost"}max=? [ F s1=12 & s2=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        01,251 0.00094,511 0.0038
        11,210 0.00253,669 0.0086
        21,469 0.01213,418 0.0260
        32,120 0.03473,769 0.0683
        43,330 0.12214,952 0.1804
        55,974 0.38107,280 0.4989
        610,4061.411012,4291.6510

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 250,633 228,206 227,315 227,297 227,297 227,297 227,297
        1,250 617,953 561,758 559,505 559,457 559,456 559,456 559,456
        2,500 1,230,1541,117,6781,113,1531,113,0561,113,0551,113,0551,113,055
        5,000 2,454,5552,229,5192,220,4502,220,2542,220,2522,220,2522,220,252
        10,0004,903,3594,453,2004,435,0454,434,6504,434,6464,434,6464,434,646
        15,0007,352,1636,676,8826,649,6396,649,0466,649,0406,649,0406,649,040
        15,8007,719,4847,010,4356,981,8296,981,2066,981,1996,981,1996,981,199
      • Maximum expected time until either station correctly delivers its packet (R{"time"}max=? [ F s1=12 | s2=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        0918 0.00093,4140.0033
        1927 0.00242,7920.0108
        21,1590.01252,6600.0340
        31,7120.03723,0030.0716
        42,8930.21523,9720.1988
        55,0320.38036,1890.7594
        69,1301.41809,9841.6505

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 2,525 2,551 2,558 2,559 2,559 2,559 2,559
        1,250 4,190 4,199 4,206 4,207 4,207 4,207 4,207
        2,500 6,963 6,946 6,952 6,953 6,953 6,953 6,953
        5,000 12,51212,44112,44512,44612,44612,44612,446
        10,000 23,63623,45123,45023,45123,45123,45123,451
        15,000 34,76134,46234,45734,45734,45734,45734,457
        15,800 36,42936,11336,10736,10836,10836,10836,108
      • Maximum expected cost until either station correctly delivers its packets (R{"cost"}max=? [ F s1=12 | s2=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        01,2470.00104,506 0.0034
        11,2000.00243,603 0.0084
        21,4520.00843,285 0.0256
        32,0960.03463,642 0.0682
        43,2760.12124,763 0.1800
        55,8560.38047,074 0.4995
        69,6511.410911,8671.6513

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 243,068 220,593 219,692 219,673 219,673 219,673 219,673
        1,250 602,888 546,644 544,381 544,333 544,332 544,332 544,332
        2,500 1,202,5891,090,0651,085,5301,085,4321,085,4311,085,4311,100,858
        5,000 2,401,9912,176,9062,167,8282,167,6302,167,6282,167,6282,167,628
        10,0004,800,7954,350,5874,332,4224,332,0264,332,0224,332,0224,332,022
        15,0007,199,5996,524,2686,497,0176,496,4226,496,4166,496,4166,496,416
        15,8007,559,4206,850,3216,821,7066,821,0826,821,0756,821,0756,821,075
      • Maximum expected time until station 1 correctly delivers its packet (R{"time"}max=? [ F s1=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        0824 0.00093,074 0.0061
        1924 0.00312,919 0.0098
        21,2010.00972,904 0.0296
        31,7740.03653,288 0.0740
        43,0120.12704,301 0.1932
        55,2470.70496,616 0.6965
        69,2741.412110,3601.6465

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 3,322 3,352 3,359 3,360 3,360 3,360 3,360
        1,250 5,572 5,581 5,586 5,587 5,587 5,587 5,587
        2,500 9,333 9,310 9,314 9,314 9,314 9,314 9,314
        5,000 16,85516,768 16,76916,76916,77016,77016,770
        10,000 31,89931,685 31,67931,68031,68031,68031,68
        15,000 46,94346,601 46,58946,59046,59046,59046,590
        15,800 49,20048,839 48,82648,82648,82648,82648,826
      • Maximum expected cost until station 1 correctly delivers its packets (R{"cost"}max=? [ F s1=12 ])

        Model checking times:

        bcmax:   TT_MAX=2,500   TT_MAX=15,000
        Iterations: Time per iter. (s): Iterations: Time per iter. (s):
        01,250 0.00094,509 0.0034
        11,206 0.00253,646 0.0083
        21,462 0.00843,373 0.0262
        32,109 0.03473,712 0.0681
        43,300 0.12124,877 0.1801
        55,923 0.38007,208 0.4975
        610,0951.408912,2161.6523

        Model checking results:

        TT_MAX   bcmax
        0 1 2 3 4 5 6
        500 247,345 224,851 223,953 223,934 223,934 223,934 223,934
        1,250 611,400 555,091 552,829 552,781 552,780 552,780 552,780
        2,500 1,218,1591,105,4941,100,9571,100,8591,100,8581,100,8581,085,431
        5,000 2,431,6752,206,2992,197,2112,197,0142,197,0122,197,0122,197,012
        10,0004,858,7094,407,9094,389,7214,389,3244,389,3204,389,3204,389,320
        15,0007,285,7426,609,5186,582,2296,581,6356,581,6286,581,6286,581,628
        15,8007,649,7976,939,7606,911,1066,910,4826,910,4756,910,4756,910,475

Case Studies