A Simple Discrete-Event Simulation: Part 33

Posted on October 31, 2016 by R.P. Churchill

My main motivation for trying to break the current functionality into M, V, and C layers isn’t about purity of design pattern so much as getting a lot of unnecessary overhead out of the simulation components themselves. They shouldn’t contain any less support functionality than they need, but they shouldn’t include any more, either.

Looking at the output and code for, say, the Queue component, shows that a lot of what’s going on inside the component itself is merely in support of the status display and timing mechanisms. I’m thinking that as much of that as possible should be moved outside of the component object itself.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
    function QueueComponent(displayDelay) {
      setOfComponents.push(this);
      this.componentID = getNewID();
      this.componentName = "Queue";
      this.entryTime = "";
      this.currentEntryEntityID = "";
      this.endEntryDisplayTime = 0;
      this.countInQueue = 0;
      this.exitTime = "";
      this.currentExitEntityID = "";
      this.exitResidenceTime = "";
      this.endExitDisplayTime = 0;
      this.endAllDisplayTime = 0;
      this.activity = "";
      this.displayDelay = displayDelay;
      this.nextComponent = null;
      this.entityQueue = [];
      //this.nextState = "clearState";
 
//      this.dataGroup = new DisplayGroup(this.componentName,175,79,80,"#00FFFF","#FF0000","#FFFF00");
      this.dataGroup = new DisplayGroup();
      this.defineDataGroup = function(x,y,vw,bc,vc,lc) {
        this.dataGroup.define(this.componentName,x,y,vw,bc,vc,lc);
      };
      this.dataGroup.addValue(this.componentID,"comp. ID","integer");
      this.dataGroup.addValue(this.entryTime,"Entry Time","numdec",5);
      this.dataGroup.addValue(this.currentEntryEntityID,"Entry ID","integer");
      this.dataGroup.addValue(this.countInQueue,"# In Queue","numdec","integer");
      this.dataGroup.addValue(this.exitTime,"Exit Time","numdec",5);
      this.dataGroup.addValue(this.currentExitEntityID,"Exit ID","integer");
      this.dataGroup.addValue(this.exitResidenceTime,"Resdnce Tm","numdec",5);
      this.dataGroup.addValue(this.activity,"Activity","text");
      
      this.assignDisplayValues = function() {
        this.dataGroup.valueList[0].value = this.componentID;
        this.dataGroup.valueList[1].value = this.entryTime;
        this.dataGroup.valueList[2].value = this.currentEntryEntityID;
        this.dataGroup.valueList[3].value = this.countInQueue;
        this.dataGroup.valueList[4].value = this.exitTime;
        this.dataGroup.valueList[5].value = this.currentExitEntityID;
        this.dataGroup.valueList[6].value = this.exitResidenceTime;
        this.dataGroup.valueList[7].value = this.activity;
      };
      this.drawData = function() {
        this.assignDisplayValues();
        this.dataGroup.drawBasic();
      };
      this.clearEntryDisplay = function() {
        //only clear display if a new one hasn't started a new timer
        if (globalSimClock >= this.endEntryDisplayTime) {
          this.entryTime = "";
          this.currentEntryEntityID = "";
          //this.exitResidenceTime = "";
        }
        if (globalSimClock >= this.endAllDisplayTime) {
          this.activity= "";        
        }
        displayProgressText("Queue entry "+this.componentID+" clears at time "+globalSimClock.toFixed(6));
      };
      this.clearExitDisplay = function() {
        //only clear display if a new one hasn't started a new timer
        if (globalSimClock >= this.endExitDisplayTime) {
          this.exitTime = "";
          this.currentExitEntityID = "";
          this.exitResidenceTime = "";
        }
        if (globalSimClock >= this.endAllDisplayTime) {
          this.activity= "";        
        }
        displayProgressText("Queue exit "+this.componentID+" clears at time "+globalSimClock.toFixed(6));
      };
      this.assignNextComponent = function(next) {
        this.nextComponent = next;
      };
      this.forwardEntity = function() {
        if (this.nextComponent.isOpen()) {
          var entity = this.entityQueue.pop();
          if (entity) {
            //calculate how long item was in queue
            this.exitResidenceTime = globalSimClock - entity.getLocalEntryTime();
            //now use this to calculate stats for the interval
                     //TODO: calculate stats as needed
            this.countInQueue--;
            this.exitTime = globalSimClock;
            this.currentExitEntityID = entity.entityID;
            this.activity = "forward entity";          
            this.endExitDisplayTime = globalSimClock+this.displayDelay;
            this.endAllDisplayTime = this.endExitDisplayTime;
            feq.newItem(this.endExitDisplayTime,this,"clearExitDisplay");
            displayProgressText("Queue comp. "+this.componentID+" forwards entity: "+this.currentExitEntityID+" at time "+globalSimClock.toFixed(6));
            this.nextComponent.receiveEntity(entity);
          }
        }
      };
      this.receiveEntity = function(entity) {
        //receive the entity
        entity.setLocalEntryTime();  //record time entity entered queue
        this.entityQueue.unshift(entity);
        this.countInQueue++;
        //display what was done
        this.entryTime = globalSimClock;
        this.currentEntryEntityID = entity.entityID;
        this.activity = "receive entity";
        //set timer to clear the display after a bit
        this.endEntryDisplayTime = globalSimClock+this.displayDelay;
        this.endAllDisplayTime = this.endEntryDisplayTime;
        feq.newItem(this.endEntryDisplayTime,this,"clearEntryDisplay");
        displayProgressText("Queue comp. "+this.componentID+" receives entity: "+this.currentEntryEntityID+" at time "+globalSimClock.toFixed(6));
        if (this.nextComponent.isOpen()) {
          this.forwardEntity();
        }
      };
      this.activate = function(nextState) {
        if (nextState == "clearEntryDisplay") {
          this.clearEntryDisplay();
        } else if (nextState == "clearExitDisplay") {
          this.clearExitDisplay();
        } else {
          errorUndefinedAdvanceState(this.entityID,this.nextState);
        }      
      };  //this.activate
      
    }  //QueueComponent

If all of the display overhead were removed from this code we’d be left with roughly this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    function QueueComponent(displayDelay) {
      setOfComponents.push(this);
      this.componentID = getNewID();
      this.componentName = "Queue";
      this.currentEntryEntityID = "";
      this.countInQueue = 0;
      this.exitResidenceTime = "";
      this.nextComponent = null;
      this.entityQueue = [];
 
      this.drawData = function() {
      };
      this.assignNextComponent = function(next) {
        this.nextComponent = next;
      };
      this.forwardEntity = function() {
        if (this.nextComponent.isOpen()) {
          var entity = this.entityQueue.pop();
          if (entity) {
            //calculate how long item was in queue
            this.exitResidenceTime = globalSimClock - entity.getLocalEntryTime();
            //now use this to calculate stats for the interval
                     //TODO: calculate stats as needed
            this.countInQueue--;
            this.currentExitEntityID = entity.entityID;
            displayProgressText("Queue comp. "+this.componentID+" forwards entity: "+this.currentExitEntityID+" at time "+globalSimClock.toFixed(6));
            this.nextComponent.receiveEntity(entity);
          }
        }
      };
      this.receiveEntity = function(entity) {
        //receive the entity
        entity.setLocalEntryTime();  //record time entity entered queue
        this.entityQueue.unshift(entity);
        this.countInQueue++;
        //display what was done
        this.currentEntryEntityID = entity.entityID;
        displayProgressText("Queue comp. "+this.componentID+" receives entity: "+this.currentEntryEntityID+" at time "+globalSimClock.toFixed(6));
        if (this.nextComponent.isOpen()) {
          this.forwardEntity();
        }
      };      
    }  //QueueComponent

You can see that gets rid of most of the code, and even some of what is left is only there to draw status information in the lower, scrolling text area.

If we want to provide the deleted capability in a more streamlined, external way then we can identify some possible requirements:

  • As much initialization and signalling as possible should be external to the simulation elements.
  • As much state information as possible should be external to the simulation elements.
  • The updating and display of such information should be able to be suppressed (or reactivated) by setting a single, global variable.
  • The external display mechanism needs to maintain a link (pointer) to the simulation element so it knows where to get its data from.
  • The simulation element may need to be able to reference an external display element via a link (pointer) but it would be better if such a link were not necessary.
  • Some displays should be permanent and updatable.
    • Since the display is always visible once defined the simulation element may not need to do anything special to allow the external display mechanism to update itself.
    • If any information in the display mechanism is to “hide” itself on a timed basis then the timing mechanism should be handled entirely within the display mechanism.
  • Some displays should be temporary on a fire-and-forget basis.
    • The internal assignment or initiation of such a display should be kept to one line.
    • If a subsequent update should happen that would change the originally initialized display before it times out, the one-line call should be able to identify the correct external display mechanism and cause it to display the updated information instead.
    • The external display mechanism should incorporate its own timing and hiding capability, if appropriate.
  • Setters and getters need to be created for all internal properties whose values will need to be displayed.
  • Functions that do external update assignments of series of values may need to be defined externally.
  • Some design decisions will reference the fact that (for the time being) the entire display is redrawn after certain classes of events, namely ones that involve processing an event from the future events queue. This idea will have to be revisited when we reincorporate wait..until events and the current events queue.
  • Given the foregoing, it may be possible to detect certain classes of events outside of the simulation elements.
This entry was posted in Simulation and tagged . Bookmark the permalink.

Leave a Reply