1 / 75

# Discrete Event Simulation - PowerPoint PPT Presentation

Discrete Event Simulation. CS1316: Representing Structure and Behavior. Story. Discrete event simulation Simulation time != real time Key ideas: A Queue A Queue is a queue, no matter how implemented. Different kinds of random Straightening time Inserting it into the right place

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'Discrete Event Simulation' - celina

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### Discrete Event Simulation

CS1316: Representing Structure and Behavior

• Discrete event simulation

• Simulation time != real time

• Key ideas:

• A Queue

• A Queue is a queue, no matter how implemented.

• Different kinds of random

• Straightening time

• Inserting it into the right place

• Sorting it afterwards

• Building a discrete event simulation

• Graphics as the representation, not the real thing: The Model and the View

• There are three Trucks that bring product from the Factory.

• On average, they take 3 days to arrive.

• Each truck brings somewhere between 10 and 20 products—all equally likely.

• We’ve got five Distributors who pick up product from the Factory with orders.

• Usually they want from 5 to 25 products, all equally likely.

• It takes the Distributors an average of 2 days to get back to the market, and an average of 5 days to deliver the products.

• Question we might wonder: How much product gets sold like this?

• We don’t want to wait that number of days in real time.

• We don’t even care about every day.

• There will certainly be timesteps (days) when nothing happens of interest.

• We’re dealing with different probability distributions.

• Some uniform, some normally distributed.

• Things can get out of synch

• A Truck may go back to the factory and get more product before a Distributor gets back.

• A Distributor may have to wait for multiple trucks to fulfill orders (and other Distributors might end up waiting in line)

• We don’t simulate every moment continuously.

• We simulate discrete events.

What’s the difference?No time loop

• In a discrete event simulation: There is no time loop.

• There are events that are scheduled.

• At each run step, the next scheduled event with the lowest time gets processed.

• The current time is then that time, the time that that event is supposed to occur.

• Key: We have to keep the list of scheduled events sorted (in order)

What’s the difference?Agents don’t act()

• In a discrete event simulations, agents don’t act().

• Instead, they wait for events to occur.

• They schedule new events to correspond to the next thing that they’re going to do.

• Key: Events get scheduled according to different probabilities.

What’s the difference?Agents get blocked

• Agents can’t do everything that they want to do.

• If they want product (for example) and there isn’t any, they get blocked.

• They can’t schedule any new events until they get unblocked.

• Many agents may get blocked awaiting the same resource.

• More than one Distributor may be awaiting arrival of Trucks

• Key: We have to keep track of the Distributors waiting in line (in the queue)

• A Queue

• A Queue is a queue, no matter how implemented.

• Different kinds of random

• Straightening time

• Inserting it into the right place

• Sorting it afterwards

Key idea #1: Introducing a Queue

• First-In-First-Out List

• First person in line is first person served

I got here third!

I got here second!

I got here first!

This is the tail of the queue

This is the front or head of the queue

• New items only get added to the tail.

• Never in the middle

• Items only get removed from the head.

I got here third!

I got here second!

I got here first!

This is the tail of the queue

This is the front or head of the queue

I got here third!

I got here second!

I got here first! AND NOW I’M UP!

Now, this is the front or head of the queue

This is the tail of the queue

Served!

I got here fourth!

I got here third!

I got here second!

Now, this is the tail of the queue

Now, this is the front or head of the queue

• push(anObject): Tack a new object onto the tail of the queue

• pop(): Pull the end (head) object off the queue.

• peek(): Get the head of the queue, but don’t remove it from the queue.

• size(): Return the size of the queue

> Queue line = new Queue();

> line.push("Fred");

> line.push("Mary");

> line.push("Jose");

> line.size()

3

> line.peek()

"Fred"

> line.pop()

"Fred"

> line.peek()

"Mary"

> line.pop()

"Mary"

> line.peek()

"Jose"

> line.pop()

"Jose"

> line.pop()

java.util.NoSuchElementException:

We don’t really want to peek() or pop() an empty queue, so we should probably check its size first.

Building aQueue

/**

* Implements a simple queue

**/

public class Queue {

/** Where we'll store our elements */

/// Constructor

public Queue(){

}

/// Methods

/** Push an object onto the Queue */

public void push(Object element){

}

/** Peek at, but don't remove, top of queue */

public Object peek(){

return elements.getLast();}

/** Pop an object from the Queue */

public Object pop(){

Object toReturn = this.peek();

elements.removeLast();

}

/** Return the size of a queue */

public int size() { return elements.size();}

We’re using a linked list to implement the Queue.

The front of the LinkedList is the tail.

• Our description of the queue minus the implementation is an example of an abstract data type (ADT).

• An abstract type is a description of the methods that a data structure knows and what the methods do.

• We can actually write programs that use the abstract data type without specifying the implementation.

• There are actually many implementations that will work for the given ADT.

• Some are better than others.

/**

* Implements a simple queue

**/

public class Queue2 {

private static int ARRAYSIZE = 20;

/** Where we'll store our elements */

private Object[] elements;

/** The indices of the head and tail */

private int tail;

Queue = array + head index + tail index

/// Constructor

public Queue2(){

elements = new Object[ARRAYSIZE];

tail = 0;

}

Queue2methods

/** Push an object onto the Queue */

public void push(Object element){

if ((tail + 1) >= ARRAYSIZE) {

System.out.println("Queue underlying implementation failed");

}

else {

// Store at the tail,

// then increment to a new open position

elements[tail] = element;

tail++; } }

/** Peek at, but don't remove, top of queue */

public Object peek(){

/** Pop an object from the Queue */

public Object pop(){

Object toReturn = this.peek();

if (((head + 1) >= ARRAYSIZE) ||

System.out.println("Queue underlying implementation failed.");

}

else {

// Increment the head forward, too.

/** Return the size of a queue */

public int size() { return tail-head;}

As the queue gets pushed and popped, it moves down the array.

Same methods, same behavior

Welcome to DrJava.

> Queue2 line = new Queue2();

> line.push("Mary")

> line.push("Kim")

> line.push("Ron")

> line.peek()

"Mary"

> line.pop()

"Mary"

> line.peek()

"Kim"

> line.size()

2

> line.pop()

"Kim"

> line.pop()

"Ron"

But can only handle up to 20 elements in the queue! Less if pushing and popping. Could shift elements to always allow 20.

Not as good an implementation as the linked list implementation. (But uses less memory.)

Key idea #2: Different kinds of random

• We’ve been dealing with uniform random distributions up until now, but those are the least likely random distribution in real life.

• How can we generate some other distributions, including some that are more realistic?

Visualizing a uniformdistribution

import java.util.*; // Need this for Random

import java.io.*; // For BufferedWriter

public class GenerateUniform {

public static void main(String[] args) {

Random rng = new Random(); // Random Number Generator

BufferedWriter output=null; // file for writing

// Try to open the file

try {

// create a writer

output =

new BufferedWriter(new FileWriter("D:/cs1316/uniform.txt"));

} catch (Exception ex) {

System.out.println("Trouble opening the file.");

}

// Fill it with 500 numbers between 0.0 and 1.0, uniformly distributed

for (int i=0; i < 500; i++){

try{

output.write("\t"+rng.nextFloat());

output.newLine();

} catch (Exception ex) {

System.out.println("Couldn't write the data!");

System.out.println(ex.getMessage());

}

}

// Close the file

try{

output.close();}

catch (Exception ex)

{System.out.println("Something went wrong closing the file");}

}

}

By writing out a tab and the integer, we don’t have to do the string conversion.

A NormalDistribution

// Fill it with 500 numbers between -1.0 and 1.0, normally distributed

for (int i=0; i < 500; i++){

try{

output.write("\t"+rng.nextGaussian());

output.newLine();

} catch (Exception ex) {

System.out.println("Couldn't write the data!");

System.out.println(ex.getMessage());

}

}

The end aren’t actually high—the tails go further.

// Fill it with 500 numbers with a mean of 5.0 and a

for (int i=0; i < 500; i++){

try{

output.write("\t"+((range * rng.nextGaussian())+mean));

output.newLine();

} catch (Exception ex) {

System.out.println("Couldn't write the data!");

System.out.println(ex.getMessage());

}

}

Multiply the random nextGaussian() by the range you want, then add the mean to shift it where you want it.

• Straightening time

• Inserting it into the right place

• Sorting it afterwards

• We’ll actually do these in reverse order:

• We’ll add a new event, then sort it.

• Then we’ll insert it into the right place.

Exercising an EventQueue

public class EventQueueExercisor {

public static void main(String[] args){

// Make an EventQueue

EventQueue queue = new EventQueue();

// Now, stuff it full of events, out of order.

SimEvent event = new SimEvent();

event.setTime(5.0);

event = new SimEvent();

event.setTime(2.0);

event = new SimEvent();

event.setTime(7.0);

event = new SimEvent();

event.setTime(0.5);

event = new SimEvent();

event.setTime(1.0);

// Get the events back, hopefull in order!

for (int i=0; i < 5; i++) {

event = queue.pop();

System.out.println("Popped event time:"+event.getTime());

}

}

}

We’re stuffing the EventQueue with events whose times are out of order.

Welcome to DrJava.

> java EventQueueExercisor

Popped event time:0.5

Popped event time:1.0

Popped event time:2.0

Popped event time:5.0

Popped event time:7.0

import java.util.*;

/**

* EventQueue

* It's called an event "queue," but it's not really.

* Instead, it's a list (could be an array, could be a linked list)

* that always keeps its elements in time sorted order.

* When you get the nextEvent, you KNOW that it's the one

* with the lowest time in the EventQueue

**/

public class EventQueue {

/// Constructor

public EventQueue(){

}

public SimEvent peek(){

return (SimEvent) elements.getFirst();}

public SimEvent pop(){

SimEvent toReturn = this.peek();

elements.removeFirst();

public int size(){return elements.size();}

public boolean empty(){return this.size()==0;}

/**

* The Queue MUST remain in order, from lowest time to highest.

**/

// Option one: Add then sort

this.sort();

//Option two: Insert into order

//this.insertInOrder(myEvent);

}

There are lots of sorts!

• Lots of ways to keep things in order.

• Some are faster – best are O(n log n)

• Some are slower – they’re always O(n2)

• Some are O(n2) in the worst case, but on average, they’re better than that.

• We’re going to try an insertion sort

• Consider the event at some position (1..n)

• Compare it to all the events before that position backwards—towards 0.

• If the comparison event time is LESS THAN the considered event time, then shift the comparison event down to make room.

• Wherever we stop, that’s where the considered event goes.

• Consider the next event…until done

// Perform an insertion sort

// For comparing to elements at smaller indices

SimEvent considered = null;

SimEvent compareEvent = null; // Just for use in loop

// Smaller index we're comparing to

int compare;

// Start out assuming that position 0 is "sorted"

// When position==1, compare elements at indices 0 and 1

// When position==2, compare at indices 0, 1, and 2, etc.

for (int position=1; position < elements.size(); position++){

considered = (SimEvent) elements.get(position);

// Now, we look at "considered" versus the elements

// less than "compare"

compare = position;

// While the considered event is greater than the compared event ,

// it's in the wrong place, so move the elements up one.

compareEvent = (SimEvent) elements.get(compare-1);

while (compareEvent.getTime() >

considered.getTime()) {

elements.set(compare,elements.get(compare-1));

compare = compare-1;

// If we get to the end of the array, stop

if (compare <= 0) {break;}

// else get ready for the next time through the loop

else {compareEvent = (SimEvent) elements.get(compare-1);}

}

// Wherever we stopped, this is where "considered" belongs

elements.set(compare,considered);

} // for all positions 1 to the end

} // end of sort()

InsertionSort

Trace this out to convince yourself it works!

• http://ciips.ee.uwa.edu.au/~morris/Year2/PLDS210/sorting.html

• http://www.cs.ubc.ca/spider/harrison/Java/sorting-demo.html

• http://www.cs.brockport.edu/cs/java/apps/sorters/insertsort.html

Recommended

These include animations that help to see how it’s all working

Option #2: Put it in the right place

/**

* The Queue MUST remain in order, from lowest time to highest.

**/

// Option one: Add then sort

//this.sort();

//Option two: Insert into order

this.insertInOrder(myEvent);

}

* Put thisEvent into elements, assuming

* that it's already in order.

**/

public void insertInOrder(SimEvent thisEvent){

SimEvent comparison = null;

// Have we inserted yet?

boolean inserted = false;

for (int i=0; i < elements.size(); i++){

comparison = (SimEvent) elements.get(i);

// Assume elements from 0..i are less than thisEvent

// If the element time is GREATER, insert here and

// shift the rest down

if (thisEvent.getTime() < comparison.getTime()) {

//Insert it here

inserted = true;

break; // We can stop the search loop

}

} // end for

// Did we get through the list without finding something

// greater? Must be greater than any currently there!

if (!inserted) {

// Insert it at the end

}

insertInOrder()

Again, trace it out to convince yourself that it works!

• Now, we can assemble queues, different kinds of random, and a sorted EventQueue to create a discrete event simulation.

Welcome to DrJava.

> FactorySimulation fs = new FactorySimulation();

> fs.openFrames("D:/temp/");

> fs.run(25.0)

Time: 1.7078547183397625 Distributor: 0 is blocking

>>> Timestep: 1

Time: 1.727166341118611 Distributor: 3 Arrived at warehouse

Time: 1.727166341118611 Distributor: 3 is blocking

>>> Timestep: 1

Time: 1.8778754913001443 Distributor: 4 Arrived at warehouse

Time: 1.8778754913001443 Distributor: 4 is blocking

>>> Timestep: 1

Time: 1.889475045031698 Distributor: 2 Arrived at warehouse

Time: 1.889475045031698 Distributor: 2 is blocking

>>> Timestep: 1

Time: 3.064560375192933 Distributor: 1 Arrived at warehouse

Time: 3.064560375192933 Distributor: 1 is blocking

>>> Timestep: 3

Time: 3.444420374970288 Truck: 2 Arrived at warehouse with load 13

Time: 3.444420374970288 Distributor: 0 unblocked!

Time: 3.444420374970288 Distributor: 0 Gathered product for orders of 11

>>> Timestep: 3

Time: 3.8869697922832698 Truck: 0 Arrived at warehouse with load 18

Time: 3.8869697922832698 Distributor: 3 unblocked!

Time: 3.8869697922832698 Distributor: 3 Gathered product for orders of 12

>>> Timestep: 3

Time: 4.095930381479024 Distributor: 0 Arrived at market

>>> Timestep: 4

Time: 4.572840072576855 Truck: 1 Arrived at warehouse with load 20

Time: 4.572840072576855 Distributor: 4 unblocked!

Time: 4.572840072576855 Distributor: 4 Gathered product for orders of 19

The detail tells the story

Notice that time 2 never occurs!

What questions we can answer warehouse

• How long do distributors wait?

• Subtract the time that they unblock from the time that they block

• How much product sits in the warehouse?

• At each time a distributor leaves, figure out how much is left in the warehouse.

• How long does the line get at the warehouse?

• At each block, count the size of the queue.

• Can we move more product by having more distributors or more trucks?

• Try it!

DESimulation: Sets the Stage warehouse

• DESimulation calls setUp to create agents and schedule the first events.

• It provides log for writing things out to the console and a text file.

• When it run()’s, it processes each event in the event queue and tells the corresponding agent to process a particular message.

What a DESimulation does: warehouse

// While we're not yet at the stop time,

// and there are more events to process

while ((now < stopTime) && (!events.empty())) {

topEvent = events.pop();

// Whatever event is next, that time is now

now = topEvent.getTime();

// Let the agent now that its event has occurred

topAgent = topEvent.getAgent();

topAgent.processEvent(topEvent.getMessage());

// repaint the world to show the movement

// IF there is a world

if (world != null) {

world.repaint();}

// Do the end of step processing

this.endStep((int) now);

}

As long as there are events in the queue, and we’re not at the stopTime:

Grab an event.

Make it’s time “now”

Process the event.

What’s an Event (SimEvent)? warehouse

/**

* SimulationEvent (SimEvent) -- an event that occurs in a simulation,

* like a truck arriving at a factory, or a salesperson leaving the

* market

**/

public class SimEvent{

/// Fields ///

/** When does this event occur? */

public double time;

/** To whom does it occur? Who should be informed when it occurred? */

public DEAgent whom;

/** What is the event? We'll use integers to represent the meaning

* of the event -- the "message" of the event.

* Each agent will know the meaning of the integer for themselves.

**/

public int message;

It’s a time, an Agent, and an integer that the Agent will understand as a message

• DEAgents define the constants for messages: What will be the main events for this agent?

• If the agent needs a resource, it asks to see if it’s available, and if not, it blocks itself.

• It will be told to unblock when it’s ready.

• Agents are responsible for scheduling their OWN next event!

An Example: A Truck warehouse

/**

* Truck -- delivers product from Factory

* to Warehouse.

**/

public class Truck extends DEAgent {

/////// Constants for Messages

public static final int FACTORY_ARRIVE = 0;

public static final int WAREHOUSE_ARRIVE = 1;

////// Fields /////

/**

* Amount of product being carried

**/

How Trucks start warehouse

/**

* Set up the truck

* Start out at the factory

**/

public void init(Simulation thisSim){

// Do the default init

super.init(thisSim);

this.setPenDown(false); // Pen up

this.setBodyColor(Color.green); // Let green deliver!

// Show the truck at the factory

this.moveTo(30,350);

// Load up at the factory, and set off for the warehouse

new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));

}

The truck gets a load, then schedules itself to arrive at the Warehouse.

/** A trip distance averages 3 days */

public double tripTime(){

double delay = randNumGen.nextGaussian()+3;

if (delay < 1)

// Must take at least one day

{return 1.0+((DESimulation) simulation).getTime();}

else {return delay+((DESimulation) simulation).getTime();}

}

/** A new load is between 10 and 20 on a uniform distribution */

return 10+randNumGen.nextInt(11);

}

How a Truck processes Events warehouse

/**

* Process an event.

* Default is to do nothing with it.

**/

public void processEvent(int message){

switch(message){

case FACTORY_ARRIVE:

// Show the truck at the factory

((DESimulation) simulation).log(this.getName()+"\t Arrived at factory");

this.moveTo(30,350);

// Load up at the factory, and set off for the warehouse

new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));

break;

Truck Arriving at the Warehouse warehouse

case WAREHOUSE_ARRIVE:

// Show the truck at the warehouse

this.moveTo(50,50);

// Unload product -- takes zero time (unrealistic!)

new SimEvent(this,tripTime(),FACTORY_ARRIVE));

break;

}

What Resources do warehouse

• They keep track of what amount they have available (of whatever the resource is).

• They keep a queue of agents that are blocked on this resource.

• They can add to the resource, or have it consume(d).

• When more resource comes in, the head of the queue gets asked if it’s enough. If so, it can unblock.

/**

* Is there enough to unblock the first

* Agent in the Queue?

**/

amount = amount + production;

if (!blocked.empty()){

// Ask the next Agent in the queue if it can be unblocked

DEAgent topOne = (DEAgent) blocked.peek();

// Is it ready to run given this resource?

// Remove it from the queue

topOne = (DEAgent) blocked.pop();

// And tell it it’s unblocked

topOne.unblocked(this);

}

}

}

/**

* Distributor -- takes orders from Market to Warehouse,

* fills them, and returns with product.

**/

public class Distributor extends DEAgent {

/////// Constants for Messages

public static final int MARKET_ARRIVE = 0;

public static final int MARKET_LEAVE = 1;

public static final int WAREHOUSE_ARRIVE = 2;

/** AmountOrdered so-far */

int amountOrdered;

Distributors start in the Market warehouse

public void init(Simulation thisSim){

//First, do the normal stuff

super.init(thisSim);

this.setPenDown(false); // Pen up

this.setBodyColor(Color.blue); // Go Blue!

// Show the distributor in the market

this.moveTo(600,460); // At far right

// Get the orders, and set off for the warehouse

amountOrdered = this.newOrders();

new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));

}

Distributors have 3 events warehouse

• Arrive in Market: Schedule how long it’ll take to deliver.

• Leave Market: Schedule arrive at the Factory

• Arrive at Warehouse: Is there enough product available? If not, block and wait for trucks to bring enough product.

Processing Distributor Events warehouse

/**

* Process an event.

* Default is to do nothing with it.

**/

public void processEvent(int message){

switch(message){

case MARKET_ARRIVE:

// Show the distributor at the market, far left

((DESimulation) simulation).log(this.getName()+"\t Arrived at market");

this.moveTo(210,460);

// Schedule time to deliver

new SimEvent(this,timeToDeliver(),MARKET_LEAVE));

break;

Leaving the Market warehouse

case MARKET_LEAVE:

// Show the distributor at the market, far right

((DESimulation) simulation).log(this.getName()+"\t Leaving market");

this.moveTo(600,460);

// Get the orders, and set off for the warehouse

amountOrdered = this.newOrders();

new SimEvent(this,tripTime(),WAREHOUSE_ARRIVE));

break;

Arriving at the Warehouse warehouse

case WAREHOUSE_ARRIVE:

// Show the distributor at the warehouse

((DESimulation) simulation).log(this.getName()+"\t Arrived at warehouse");

this.moveTo(600,50);

// Is there enough product available?

FactoryProduct factory = ((FactorySimulation) simulation).getFactory();

if (factory.amountAvailable() >= amountOrdered)

{

// Consume the resource for the orders

factory.consume(amountOrdered); // Zero time to load?

((DESimulation) simulation).log(this.getName()+"\t Gathered product for orders of \t"+amountOrdered);

// Schedule myself to arrive at the Market

new SimEvent(this,tripTime(),MARKET_ARRIVE));

}

else {// We have to wait until more product arrives!

((DESimulation) simulation).log(this.getName()+"\t is blocking");

waitFor(((FactorySimulation) simulation).getFactory());}

break;

Is there enough product? warehouse

/** Are we ready to be unlocked? */

// Is the amount in the factory more than our orders?

return ((FactorySimulation) simulation).getFactory().

amountAvailable() >= amountOrdered;}

If so, we’ll be unblocked warehouse

/**

* I've been unblocked!

* @param resource the desired resource

**/

public void unblocked(Resource resource){

super.unblocked(resource);

// Consume the resource for the orders

((DESimulation) simulation).log(this.getName()+"\t unblocked!");

((FactoryProduct) resource).consume(amountOrdered); // Zero time to load?

((DESimulation) simulation).log(this.getName()+"\t Gathered product for orders of \t"+amountOrdered);

// Schedule myself to arrive at the Market

new SimEvent(this,tripTime(),MARKET_ARRIVE));

}

The Overall Factory Simulation warehouse

/**

* FactorySimulation -- set up the whole simulation,

* including creation of the Trucks and Distributors.

**/

public class FactorySimulation extends DESimulation {

private FactoryProduct factory;

/**

* Accessor for factory

**/

public FactoryProduct getFactory(){return factory;}

Setting up the Factory Simulation warehouse

public void setUp(){

// Let the world be setup

super.setUp();

// Give the world a reasonable background

FileChooser.setMediaPath("D:/cs1316/MediaSources/");

world.setPicture(new Picture(

FileChooser.getMediaPath("EconomyBackground.jpg")));

// Create a factory resource

factory = new FactoryProduct(); //Track factory product

// Create three trucks

Truck myTruck = null;

for (int i=0; i<3; i++){

myTruck = new Truck(world,this);

myTruck.setName("Truck: "+i);}

// Create five Distributors

Distributor sales = null;

for (int i=0; i<5; i++){

sales = new Distributor(world,this);

sales.setName("Distributor: "+i);}

}

A Class that Shouldn’t Exist warehouse

/**

* FactoryProduct -- Represents the products

* in the factory, which is the resource that

* the Truck produces and the Distributor consumes.

**/

public class FactoryProduct extends Resource {

}

The Master Data Structure List: warehouseWe use almost everything here!

• Queues: For storing the agents waiting in line.

• EventQueues: For storing the events scheduled to occur.

• LinkedList: For storing all the agents.