1. Discrete Event Simulation
Speaker: Yeh, En-Hau
Advisor: Phone Lin
MCN Lab., Dept. of CSIE, NTU
TEL: #538

2. Grading Midterm Exam 40% 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

3. Grading Find a paper with the analytical model Where to find a paper?
IEEE Xplore:
ACM Digital Library:
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
Magazines
IEEE Personal Communications Magazine
IEEE Communications Magazine
IEEE Wireless Communications Magazine

4. Outline Introduction to Simulation Simulation Implementation
What is Simulation?
Why Simulate?
System & Simulation
Simulation Implementation
A Simulation Example
M/M/c/c
Handoff Model

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.

6. What is Simulation?

7. Why Simulate? (Example)
stack
landing

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.

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.

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

11. Simulation Static/Dynamic Simulation Continuous/Discrete Simulation
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

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

13. Discrete-Event Simulation
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
For example, the process of arrival at and departure from a voip server occurs in random fashion. The only way we can represent this randomness is by using probability distributions to describe.

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

15. Simulation Implementation

16. Simulation Implementation
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.
Programming Language C
C++
Java C# …
Priority Queue in C++ Standard Template Library
priority_queue<T, Sequence, Compare>
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

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]

18. Inverse Transform Method1
F(x) yj
F-1(yj) yi
Probability
Uniform(0,1) xi xj X

19. Inverse Transform Method
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)

20. Inverse Transform Method
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)/ λ
Note: u!=0

21. Inverse Transform Method
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

22. Generating Gamma-distributed

23. Generating Gamma-distributed

24. A SIMULATION EXAMPLE M/M/c/C

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)

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

27. Analysis: M/M/c/c (Erlang B)λ λ λ λ λ … 1 2
c-1 c μ 2μ 3μ
(c-1)μ cμ

28. Simulation Models: M/M/c/c
ARRIVAL event represents a customer arrival.
arrival1
arrival2
departure1
generate next call: arrival2
if channel > 0 then channel-- and generate service time: departure1

29. Simulation Models: M/M/c/c
arrival1
arrival2
arrival3
departure1
departure2
generate next call: arrival3
if channel > 0 then channel-- and generate service time: departure2

30. Simulation Models: M/M/c/c
DEPARTURE event represents a customer departure .
arrival1
arrival2
arrival3
departure1
departure2
channel++

31. Simulation Models: M/M/c/c
Assume that c=2
Arrival5 is Blocking
Pb = N_blocking / N_arrival
arrival1
arrival2
arrival3
arrival4
arrival5
arrival6
departure1
departure2
departure4
generate next call: arrival6
if channel = 0 then N_blocking++

32. Simulation Models: Event Class

33. Simulation Models: Initialize
實驗次數100萬次

34. Simulation Models: Timing Routine
generate next call
if channel > 0 then
channel
generate service time
if channel = 0 then N_blocking++
channel++

35. Simulation Models: Report
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

36. Priority Queue

37. A SIMULATION EXAMPLE Handoff Model

38. 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.

39. A Simulation Example Handoff Model

40. 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. System Model – Assumptions (2/4)

42. System Model – Assumptions (3/4)
Each hard handoff call can only connect to one BS.

43. System Model – Assumptions (4/4)
Wrapped mesh cell: N*N => 8*8
The boundary cell effects can be ignored

44. Simulation Models: Event Design
A HANDOFF event
An ARRIVAL event
A RELEASE event

45. 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. Timing Diagram for one call
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.

47. Residual-life τ0
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 on  Networking, Sensing and Control, Vol 1, pp , March 2004.

48. Timing Diagram for multiple call
first call
Event List
Call 1
Arrival
(t=0)
Call 1
Handoff
(t=4)
Call 2
Arrival
(6)
Call 2
Arrival
(t=6)
generate next call arrival2
generate service time
generate cell residence time
insert ARRIVAL event
if channel>0 {
channel--
if (service time > residence time)
insert HANDOFF event
else
insert RELEASE event }

49. Timing Diagram for multiple call
Event List
Call 1
Arrival
(t=0)
Call 1
Handoff
(t=4)
Call 2
Arrival
(6)
Call 2
Arrival
(t=6)
Call 1
RELEASE
(t=14)
Call 3
Arrival
(t=20)
channel++
generate next call arrival3
generate cell residence time
if channel==0
N_Blocking++
compare the service time and the residence time
if (service time > residence time)
insert HANDOFF event
else
insert RELEASE event

50. Example: Event List and Event Struct …

51. 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 */ case RELEASE: /*Process flowchart for RELEASE event */ } /*Calculate the desired performance measures and output the result */

52. Flow Chart

53. 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.

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

55. Reference http://www.erlang.com/calculator/erlb Gamma distribution
Erlang B Calculator
Latex
GNUPlot
M/M/c/c Sample Source Code