[PPT] - Discrete Event Simulation Speaker: Lee, Chia-Peng Advisor: Phone PowerPoint Presentation

SLIDE 1

Discrete Event Simulation

Speaker: Lee, Chia-Peng Advisor: Phone Lin MCN Lab., Dept. of CSIE, NTU Email: jet.lee@pcs.csie.ntu.edu.tw TEL: +886-2-33664888#538

SLIDE 2

Grading

Midterm Exam 35% Final Exam 30% Final Project 30%

Step 1: Find a paper with the analytical model
Step 2: Read the paper in detail
Step 3: Write the simulation to validate the analytical model
Step 4: Compare the errors of your simulation results with the results in

the paper

[optional] Step 5: Do some more if you can (e.g., performance analysis

via simulation or analytical models).

Step 6: Prepare your presentation

Report 5%

2

SLIDE 3

Grading

Find a paper with the analytical model

Where to find a paper?
IEEE Xplore: http://ieeexplore.ieee.org/Xplore/guesthome.jsp
ACM Digital Library:

http://portal.acm.org/

Which Journal/Magazine?
Journals
IEEE Transactions on Vehicular Technology
IEEE Journal on Selected Areas in Communications
IEEE Transactions on Mobile Computing
IEEE Networks
IEEE Transactions on Computer
IEEE Communications Letter
IEEE Transactions on Wireless Communication
IEICE Transactions on Communication
Security and Communication Networks
ACM/Springer Wireless Networks
Journal of Wireless Communications and Mobile Computing
ACM/Springer Mobile Networks and Applications

3

Magazines
IEEE Personal Communications Magazine
IEEE Communications Magazine
IEEE Wireless Communications Magazine

SLIDE 4

Outline

Introduction to Simulation

What is Simulation?
Why Simulate?
System & Simulation

Simulation Implementation A Simulation Example

M/M/c/c
Handoff Model

4

SLIDE 5

What is Simulation?

Simulation is the imitation of some real thing, state of affairs, or process. Simulation is defined as the process of creating a model of an existing or proposed system to gain some understanding of how the corresponding system behaves.

5

SLIDE 6

What is Simulation?

System Experiment and real system Experiment with an “emulation” system (real traffic input/output) Experiment with simulations and models Test it in a testing environment (with generated traffic) Put the system in the real environment and use it (with real traffic) Physical models Mathematical models (execution in no real-time, non real traffic input/output) Analysis (Queueing Therory) Simulation 6

SLIDE 7

Why Simulate? (Example)

7

landing stack

SLIDE 8

8

Why Simulate? (Example Cont.)

An Example of Simulation in the Real World

The Airport Problem
The airport has two runways, one for landing and one for takeoff. If the

landing way is busy, the airplane in the air must enter in a stack. However, when the stack is full, the takeoff way must become landing way.

Airports have a waiting stack, where airplanes wait before they can land. In

this stack, airplanes fly a holding pattern on an assigned altitude.

What we want to know?
Calculate the stack length.
The average time a plane waits for takeoff.
The average utilization of the landing way and the takeoff way.

SLIDE 9

9

Why Simulate? (Example Cont.)

Such measures of performance can get from historical data records. However, we are interested in the impact of certain proposed changes.

Landing airplane arrival rate.
Takeoff airplane arrival rate.
Increasing the runways.

SLIDE 10

Why Simulate?

Save time Reduce cost Test design ideas (performance measurement)

The impact of certain changes of parameter.
The arrival rate of certain traffic class.
The service time of certain traffic class.
The number of application server.

Predict the future behavior of the system

10 10

SLIDE 11

Simulation

Static/Dynamic Simulation

Static
Time simply plays no role
Dynamic
A system evolves over time

Continuous/Discrete Simulation

Continuous
The state change continuously with respect to time
Discrete
The state change instantaneously at separated points in

time

11 11

SLIDE 12

Discrete-Event Simulation

Dynamic

Simulation clock
Keep track of the current value of simulated time as the simulation

proceeds

A mechanism to advance simulated time from one value to

another

Discrete

The state change instantaneously at separate points in time
The system can change at only a countable number of points in

time.

These points in time are the ones at which an event occurs.
Event
An instantaneous occurrence that may change the state of the

system

12 12

SLIDE 13 1

a

2

a

1

d

3

a

2

d Time e

1

e

2

e

3

e

4

e

5

e A1 A2 A3 S1 S2

All state changes occur only at event times for a discrete-event simulation model

Periods of inactivity are skipped over by jumping the clock from event

time to event time

Stochastic

Interarrival times A1, A2,… and service times S1, S2,…
Are random variables
Have cumulative distribution functions

13

Discrete-Event Simulation

SLIDE 14

14 14

The Phase of Simulation

Construction

Formularize the problem
Collecting necessary input data as parameter (arrival

rate, departure rate)

Design a simulation model to match the problem

Running

Run this simulation for enough time to estimate the

system’s result.

Debugging

See if the result make sense.
Compare to an analytic model

SLIDE 15

SIMULATION IMPLEMENTATION

SLIDE 16

Simulation Implementation

Programming Language

C
C++
Java
C#
…

16 16

Event

An instantaneous occurrence that

may change the state of the system

Attributes of an event

Type (e.g., arrival, departure, etc.)
Timestamp
Other attributes
Location info.

Event List

Event list is a linked list
Events are sorted according to the timestamp value.
Automatically adjusts the event order at each event insertion.

Efficiency

Data structure: link-list v.s. min-Heap data structure
Time Complexity
Memory allocation management
Freelist

Priority Queue in C++ Standard Template Library

priority_queue<T, Sequence, Compare>

SLIDE 17

Random Number Generator

R.N.G.’s for various probability distributions

Used when we need a time period with a certain

distribution

Uniform, exponential, gamma, etc.

Implementation

The inverse transform method
CDF: F(x) = Pr[ X ≤ x]

17 17

SLIDE 18

Inverse Transform Method

18 18

F(x)

1 Probability

X F-1(yj)

xi yj yi xj Uniform(0,1)

SLIDE 19

Inverse Transform Method

19 19

Validity of this method:

Whether r.v. F-1(U) has the CDF F(x)?

F’(x) = Pr[F-1(U) ≤ x] = Pr[U ≤ F(x)] = FU( F(x) ) = F(x)

SLIDE 20

Inverse Transform Method

20 20

Example: exponential distribution with rate

CDF: F(x) = 1 - e -λX
Set F(X) = U

=> 1 - e-λX = U => e-λX = 1-U => -λX = ln(1-U) => X = -ln(1-U)/ λ = -ln(U)/ λ Note: u!=0

SLIDE 21

Inverse Transform Method

21 21

Applicable when the inverse function of F(x), i.e., F-1(x), can be derived Preferably when F-1(x) has an east-to-use form Steps:

Generate a uniform (0,1) random number u
Compute x = F-1(u), and x is the desired random

number

SLIDE 22

Generating Gamma-distributed

22 22

SLIDE 23

Generating Gamma-distributed

23 23

SLIDE 24

A SIMULATION EXAMPLE

M/M/C/C

SLIDE 25

25 25

Queueing System

Key elements: customers and servers

Customer: arrival process
Server: service rate and number of servers

Notation: A/B/c/N/K

A: inter-arrival time distribution (arrival process)
B: service time distribution
c : number of servers/channels
N: system capacity
K: queue discipline (Unless specified, it is assumed to be

First-In-First-Out)

SLIDE 26

26 26

Queueing System

M/M/c/c

The 1st M: Markovian / Memoryless
Possision arrivals / exponential inter-arrival time
The 2nd M: Markovian
Exponential service time
c: c servers/channels
c: system capacity

Blocking

SLIDE 27

Analysis: M/M/c/c (Erlang B)

27 27

1 2 c-1 c

…

λ λ λ λ λ μ 2μ (c-1)μ cμ 3μ

SLIDE 28

Simulation Models: M/M/c/c

28 28

arrival1 arrival2 departure1

1. generate next call: arrival2
2. if channel > 0 then channel-- and generate service time: departure1
ARRIVAL event represents a customer arrival.

SLIDE 29

Simulation Models: M/M/c/c

29 29

arrival1 arrival2 departure1 arrival3 departure2

1. generate next call: arrival3
2. if channel > 0 then channel-- and generate service time: departure2

SLIDE 30

Simulation Models: M/M/c/c

30 30

arrival1 arrival2 departure1 arrival3 departure2

1. channel++
DEPARTURE event represents a customer departure .

SLIDE 31

Simulation Models: M/M/c/c

31 31

arrival1 arrival2 departure1 arrival3 departure2

1. generate next call: arrival6
2. if channel = 0 then N_blocking++

arrival4 arrival5 arrival6 departure4

Assume that c=2 Arrival5 is Blocking Pb = N_blocking / N_arrival

SLIDE 32

Simulation Models: Event Class

32 32

SLIDE 33

Simulation Models: Initialize

33 33

實驗次數100萬次

SLIDE 34

Simulation Models: Timing Routine

34 34

if channel > 0 then channel generate service time generate next call if channel = 0 then N_blocking++ channel++

SLIDE 35

Simulation Models: Report

35 35

M/M/c/c

Inter-arrival time is Exponential distribution with rate 50.0
Service time is Exponential distribution with rate 10.0
c: number of channels is 8
c: system capacity is 8

http://www.erlang.com/calculator/erlb

SLIDE 36

Priority Queue

36 36

SLIDE 37

Priority Queue

37 37

SLIDE 38

A SIMULATION EXAMPLE

HANDOFF MODEL

SLIDE 39

39

A Simulation Example Handoff Model

When the network attempts to deliver a call to a handset or the handset attempts to originate a call, the call is connected if a channel is available. Otherwise, the call is blocked (referred to as the new call blocking). When a handset moves from one cell to another during a call, in order to maintain call continuation the channel in the old cell is released, and a channel is required in the new cell. This process is called hand-off. If no channel is available in the new base station, then the hand-off call is force-terminated.

SLIDE 40

40

MSC Old BS New BS MSC Old BS New BS

(a) Step 1 (b) Step 2

MSC Old BS New BS MSC Old BS New BS

(c) Step 3 (d) Step 4

A Simulation Example Handoff Model

SLIDE 41

System Model – Assumptions (1/4)

Each cell consists of

One base station
Several channels
Several mobile station

A mobile user can carry only a call We do not consider batch arrivals of new and handoff calls

41 41

SLIDE 42

System Model – Assumptions (2/4)

42

SLIDE 43

System Model – Assumptions (3/4)

Each hard handoff call can only connect to one BS.

BS1 BS2 BS3 BS4 BS5

43

SLIDE 44

System Model – Assumptions (4/4)

Wrapped mesh cell: N*N => 8*8

The boundary cell effects can be ignored

SLIDE 45

45

A HANDOFF event An ARRIVAL event A RELEASE event

Simulation Models: Event Design

SLIDE 46

Simulation Models: Event Design

We define three types of events for traditional calls :

ARRIVAL event represents a new call arrival.
Call_Type is maintained in this event to indicate that the event is for a

(Call_type = Traditional)

A channel is required
HANDOFF event represents a handoff call arrival.
The Call_Type variable is used to indicate that the event is for a traditional

call (Call_type = Traditional)

The channel in the old cell is released, and a channel is required in

the new cell.

RELEASE event represents the completion of a call.
Call_Type indicates that the event is for a traditional call (Call_type =

Traditional)

The channel is released.

46 46

SLIDE 47

Timing Diagram for one call

47 47

tc: the call holding time of a portable. tc,i: the period between the time the portable moves into coverage area i and the time when the call is complete. tm,i: the residence time of a portable at a coverage area i. τ0: the time between the arrival of the call and when the portable moves out of coverage area 0.

SLIDE 48

Residual-life τ0

48 48

Generation of an residual-life random number for gamma residence time with the parameters (k, θ) includes the following steps: We first generate a uniform random number μ in (0, 1). Second, we generate a random number t for the gamma random variable T with the parameters (k+1, θ). By multiplying u and t, we obtain a random number for the residual τ0. τ0=U*Gamma(k+1, θ)

Yi-Bing Lin, “Random Number Generation for Residual Life of Mobile Phone Movement”, IEEE International Conference

n Networking, Sensing and Control, Vol 1, pp. 30-33, March 2004.

SLIDE 49

Timing Diagram for multiple call

49

Call 1 Arrival (t=0)

Event List

Call 2 Arrival (6)

1. generate next call arrival2
2. generate service time
3. generate cell residence time

insert ARRIVAL event if channel>0 { channel-- if (service time > residence time) insert HANDOFF event else insert RELEASE event }

first call

Call 1 Handoff (t=4) Call 2 Arrival (t=6)

SLIDE 50

Timing Diagram for multiple call

50

Call 1 Arrival (t=0)

Event List

Call 2 Arrival (6) Call 1 RELEASE (t=14)

1. generate cell residence time

compare the service time and the residence time if (service time > residence time) insert HANDOFF event else insert RELEASE event

Call 1 Handoff (t=4) Call 2 Arrival (t=6)

if channel==0 N_Blocking++ channel++

1. generate next call arrival3

Call 3 Arrival (t=20)

SLIDE 51

Example: Event List and Event Struct

51 51

…

Event Struct Event List

SLIDE 52

Simulation Models: Timing Routine

/* initialization */ /* generate the first event and insert it into the event list */ While(Number_of_Case <= Bound){ /* retrieve the first event from event list */ /* adjust the system clock according to the timestamp of current event */ switch(event_type){ case ARRIVAL : /*Process flowchart for ARRIVAL event */ break; case HANDOFF: /*Process flowchart for HANDOFF event */ break; case RELEASE: /*Process flowchart for RELEASE event */ break; } } /*Calculate the desired performance measures and output the result */

52 52

SLIDE 53

53 53

Flow Chart

Start (1) Set initial values (2) Generate a traditional call ARRIVAL event for each cell (3) Delete next event e from the event list according the timestamp of the event (4) Check the type of event e (6) channel available? (5) Call_Type ? (10) Call_Type ? (8) one channel is allocated to the request (9) CRt = CRt + 1; (7) The request is blocked (11) Release one channel (12) CRt = CRt - 1; (13) Call_Type ? (14) channel available? (16) one channel is allocated to the request and release old channel (17) CRt = CRt + 1; (15) The handoff request is block. Traditional NO YES Traditional Traditional NO YES ARRIVAL RELEASE HANDOFF

SLIDE 54

54 54

The notations

The new traditional call arrival rate to a cell is exponentially distributed with the rate . The call holding time for a traditional call is exponentially distributed with the mean . The UE residence time in a cell has an exponential distribution with the mean . The total channels in a cell are C. The call incompletion probability for a traditional call is Pnc,t.

SLIDE 55

Analysis and Simulation Validation

55 55

The input parameters and are normalized by . We assume there are C=10 channels per cell.

SLIDE 56

Reference

Gamma distribution

http://en.wikipedia.org/wiki/Gamma_distribution

Erlang B Calculator

http://www.erlang.com/calculator/erlb

Latex

http://www.latex-project.org/
http://miktex.org/

GNUPlot

http://www.gnuplot.info/

M/M/c/c Sample Source Code

http://pcs.csie.ntu.edu.tw/course/performance/2012/Simulation_MMCC.rar

56 56