SimulationsUsingSimPy/NetworkOfQueues.py at master · gallettilance/SimulationsUsingSimPy · GitHub

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
from SimPy.Simulation import *
import random as rnd
import numpy.random as rnp
import argparse
import matplotlib.pyplot as plt


class Parameters:

    vM = Monitor()
    vMcpuwait = Monitor()
    vMcpulength = Monitor()
    vMdisk = Monitor()
    vMnet = Monitor()
    packageArrivalCounter = 0
    seed = 123


#generate packets with poisson arrival rate (so exponential interarrival time)
class CPUGenerator( Process ):
    def produce( self, b ):
        while True:
            c = CPU_Behavior( b, Parameters.packageArrivalCounter )
            c.start( c.doit() )
            Parameters.packageArrivalCounter +=1
            yield hold, self, rnd.expovariate(40)


#CPU queue (MM2)
class CPU_Behavior( Process ):
    def __init__( self, resource, i ):
        Process.__init__( self )
        self.i = i
        self.bank = resource

    def doit( self ):
        arrive = now()
        print "Time %f : %d arrived and about to join the CPU queue  "%(now(), self.i)
        yield request, self, self.bank
        wait = now() - arrive
        Parameters.vMcpu.observe(wait)
        print "Time %f : %d is about to get its CPU service initiated "%(now(), self.i)
        yield hold, self, self.bank.servicetime()
        yield release, self, self.bank
        print "Time %f : %d CPU service terminated " %(now(), self.i)

        rand = rnd.uniform(0,1)
        if rand < .1:
            DiskBank = Disk(capacity=1, monitored=True, monitorType=Monitor)
            c = Disk_Behavior( DiskBank, self.i )
            activate( c, c.doit(), prior=True )
        if rand > .6:
            NetBank = Network(capacity=1, monitored=True, monitorType=Monitor)
            c = Network_Behavior( NetBank, self.i )
            activate( c, c.doit(), prior=True )

    def again( self ):
        print "Time %f : %d arrived and about to join the CPU queue  "%(now(), self.i)
        yield request, self, self.bank
        print "Time %f : %d is about to get its CPU service initiated "%(now(), self.i)
        yield hold, self, self.bank.servicetime()
        yield release, self, self.bank
        print "Time %f : %d CPU service terminated " %(now(), self.i)
        rand = rnd.uniform(0,1)
        if rand < .1:
            DiskBank = Disk(capacity=1, monitored=True, monitorType=Monitor)
            c = Disk_Behavior( DiskBank, self.i )
            activate( c, c.doit(), prior=True )
        if rand > .6:
            NetBank = Network(capacity=1, monitored=True, monitorType=Monitor)
            c = Network_Behavior( NetBank, self.i )
            activate( c, c.doit(), prior=True)

#Disk Queue (MM1)
class Disk_Behavior( Process ):
    def __init__( self, resource, i ):
        Process.__init__( self )
        self.i = i
        self.bank = resource


    def doit( self ):
        arrive = now()
        print "Time %f : %d arrived and about to join the disk queue  "%(now(), self.i)
        yield request, self, self.bank
        wait = now() - arrive
        Parameters.vMdisk.observe(wait)
        print "Time %f : %d is about to get its disk service initiated "%(now(), self.i)
        yield hold, self, self.bank.servicetime()
        yield release, self, self.bank
        print "Time %f : %d disk service terminated " %(now(), self.i)
        rand = rnd.uniform(0,1)
        if rand < .5:
            CPUBank = CPU( capacity=2, monitored=True, monitorType=Monitor )
            c = CPU_Behavior( CPUBank, self.i )
            activate( c, c.again(), prior=True  )
        else:
            NetBank = Network(capacity=1, monitored=True, monitorType=Monitor)
            c = Network_Behavior( NetBank, self.i )
            activate( c, c.doit(), prior=True  )


#Network queue (MM1)
class Network_Behavior( Process ):

    def __init__( self, resource, i ):
        Process.__init__( self )
        self.i = i
        self.bank = resource


    def doit( self ):
        arrive = now()
        print "Time %f : %d arrived and about to join the Network queue  "%(now(), self.i)
        yield request, self, self.bank
        wait = now() - arrive
        Parameters.vMnet.observe(wait)
        print "Time %f : %d is about to get its Network service initiated "%(now(), self.i)
        yield hold, self, self.bank.servicetime()
        yield release, self, self.bank
        print "Time %f : %d Network service terminated " %(now(), self.i)
        CPUBank = CPU( capacity=2, monitored=True, monitorType=Monitor )
        c = CPU_Behavior( CPUBank, self.i )
        activate( c, c.again(), prior=True  )


#generate exponential service time
class CPU( Resource ):
    def servicetime( self ):
        return rnd.expovariate(1.0/.02)

class Disk( Resource ):
    def servicetime( self ):
        return rnd.expovariate(1.0/.1)

class Network ( Resource ):
    def servicetime( self ):
        return rnd.expovariate(1.0/.025)


#run simulation
def run_simulation( totaltime, numberofsimulations ):
    for r in range(numberofsimulations):
        CPUBank = CPU( capacity=2, monitored=True, monitorType=Monitor ) #make CPU MM2

        initialize()
        src = CPUGenerator()
        activate( src, src.produce( CPUBank ))

        startCollection(when=totaltime)
        simulate(until=2*totaltime)

        result = Parameters.vMcpu.count(), Parameters.vMcpu.mean()
        Parameters.seed+= 25
        print "Average wait for %3d completions was %5.3f seconds."% result


run_simulation( 100, 1)