For users of SimPy, a discrete event simulation package for Python ()

Code for a G/G/c/K queueing system

I have attached a Python file (GGcI.py) that uses SimPy to simulate a 
G/G/c/K queueing system. It could be useful for teaching/tutorial 
purposes when studying queueing systems. Any feedback (positive or 
negative) would be appreciated.

V. Stokes

"""GGcI.py

This is a SimPy implementation for a general G/G/c/K queueing system. The main
 purpose is to show how to produce a file containing state changes that occur 
 during a simulation (state transition matrix). In addition is shows how balking
 and reneging in queueing systems can be handled.

System under study
 Customers arrive at random to a c-server queueing system (bank) and have service
 times from an exponential distribution. A single FIFO queue can form when all 
 tellers (slots for resource) are busy. The number of customers in the system is
 limited to K (if BALK = True).

Note:
  1) The output file produced (ASCII format) has a default name statematrix.txt. 
     This output file can be used as input to other Python programs for additional
     processing. Example, QueueAnimatorD.py, uses this state transistion matrix to
     animate queueing systems. 
  2) Balking and reneging are allowable states. The balking rule is based on the
     the number in the system when a new customer arrives. When the number of
     customers in the system is more than LMAX_B, then balking can occur. That is,
     K = LMAX_B. Reneging will occur when the 2nd, or 3rd, or ... customer in the

(Continue reading)

headers

Srikanth | 21 Dec 08:00

SimPy waitevent activations

Hello,
I am a newbie user of SimPy and am new to simulation in general. I have written a small SimPy program to understand how the signalling via waitevent works. The following is the program:
#-------------------------------begin code --------------------------------------------------
from SimPy.Simulation import *

class Responder(Process) :
    def respond(self,ev):
        while True:
            print "Inside respond() of %s"%self.name
            yield waitevent,self,ev

class Scheduler(Process):
    def schedule(self):
        resp1 = Responder("Responder 1")
        resp2 = Responder("Responder 2")
        resp3 = Responder("Responder 3")
        sig = SimEvent()
        while True:
            activate(resp1,resp1.respond(sig))
            activate(resp2,resp2.respond(sig))
            activate(resp3,resp3.respond(sig))
            sig.signal ()
            print "Sent a signal %s" %sig.name
            yield hold,self,1

def execute():
    print "\n"*5
    print "-"*10
    initialize()
    s = Scheduler()
    activate(s,s.schedule())
    simulate(until=1)

if __name__ == '__main__':
    execute()
#-------------------------------end code -----------------------------------------------------

For the sake of simplicity, I ran the simulation for one time click, however, the results look similar for other iterations, too.
The following is the output
#-----------------------------------begin output---------------------------------------------
Inside respond() of Responder 1
Inside respond() of Responder 1
Inside respond() of Responder 2
Inside respond() of Responder 3

Sent a signal a_SimEvent

Inside respond() of Responder 3
Inside respond() of Responder 2
Inside respond() of Responder 1

#-----------------------------------end output------------------------------------------------

My question is this: why does the process execution method (PEM) of the Responder 1 object get called twice the first time - I expected it to be called only once. Any explanation that anyone on the list can provide is greatly appreciated.
Thanks in advance.
Srikanth.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2005.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/

_______________________________________________
Simpy-users mailing list
Simpy-users <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/simpy-users

headers

kgmuller | 21 Dec 14:07

Re: SimPy waitevent activations

Srikanth,

you get this from the multiple activation of the Responder processes. You should activate a Process instance only once.

So, here is a better structure for your test:

from SimPy.Simulation import *

class Responder(Process) :
    def respond(self,ev):
        while True:
            print "Inside respond() of %s"%self.name
            yield waitevent,self,ev
            print "%s got signal"%self.name

class Scheduler(Process):
def schedule(self,ev):

        while True:
            ev.signal ()
            print "Sent a signal %s" %ev.name
            yield hold,self,1

def execute():
    print "\n"*5
    print "-"*10
    initialize()
    resp1 = Responder("Responder 1")
    resp2 = Responder("Responder 2")
    resp3 = Responder("Responder 3")
    sig = SimEvent()
    activate(resp1,resp1.respond(sig))
    activate(resp2,resp2.respond(sig))
    activate(resp3,resp3.respond(sig))
    s = Scheduler()
    activate(s,s.schedule(sig))
    simulate(until=1)

if __name__ == '__main__':
execute()

When run, you get:

----------
Inside respond() of Responder 1
Inside respond() of Responder 2
Inside respond() of Responder 3
Sent a signal a_SimEvent
Responder 3 got signal
Inside respond() of Responder 3
Responder 2 got signal
Inside respond() of Responder 2
Responder 1 got signal
Inside respond() of Responder 1
Sent a signal a_SimEvent
Responder 1 got signal
Inside respond() of Responder 1
Responder 2 got signal
Inside respond() of Responder 2
Responder 3 got signal
Inside respond() of Responder 3

Which is perfectly ok.

Klaus

From: simpy-users-bounces <at> lists.sourceforge.net [mailto:simpy-users-bounces <at> lists.sourceforge.net] On Behalf Of Srikanth
Sent: Friday, December 21, 2007 8:01 AM
To: simpy-users <at> lists.sourceforge.net
Subject: [Simpy-users] SimPy waitevent activations

Hello,
I am a newbie user of SimPy and am new to simulation in general. I have written a small SimPy program to understand how the signalling via waitevent works. The following is the program:
#-------------------------------begin code --------------------------------------------------
from SimPy.Simulation import *

class Responder(Process) :
    def respond(self,ev):
        while True:
            print "Inside respond() of %s"%self.name
            yield waitevent,self,ev

class Scheduler(Process):
    def schedule(self):
        resp1 = Responder("Responder 1")
        resp2 = Responder("Responder 2")
        resp3 = Responder("Responder 3")
        sig = SimEvent()
        while True:
            activate(resp1,resp1.respond(sig))
            activate(resp2,resp2.respond(sig))
            activate(resp3,resp3.respond(sig))
            sig.signal ()
            print "Sent a signal %s" %sig.name
            yield hold,self,1

def execute():
    print "\n"*5
    print "-"*10
    initialize()
    s = Scheduler()
    activate(s,s.schedule())
    simulate(until=1)

if __name__ == '__main__':
    execute()
#-------------------------------end code -----------------------------------------------------

For the sake of simplicity, I ran the simulation for one time click, however, the results look similar for other iterations, too.
The following is the output
#-----------------------------------begin output---------------------------------------------
Inside respond() of Responder 1
Inside respond() of Responder 1
Inside respond() of Responder 2
Inside respond() of Responder 3

Sent a signal a_SimEvent

Inside respond() of Responder 3
Inside respond() of Responder 2
Inside respond() of Responder 1

#-----------------------------------end output------------------------------------------------

My question is this: why does the process execution method (PEM) of the Responder 1 object get called twice the first time - I expected it to be called only once. Any explanation that anyone on the list can provide is greatly appreciated.
Thanks in advance.
Srikanth.

-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2005.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/

_______________________________________________
Simpy-users mailing list
Simpy-users <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/simpy-users

headers

kgmuller | 23 Dec 08:05

Beta-release of SimPy version 1.9

All:
It is our pleasure to announce the beta-release of SimPy 1.9. This is for
testing only. 
SimPy 1.8 is still the stable/production version.

Please, download, test and report any problems (or maybe even positive
feedback) to this list.

This release makes improvements to event handling which should result 
in significantly shorter execution times for large models (thousands of
processes) 
and models with a high percentage of cancel and passivate statements. 

The ideas for speed improvement came from three contributors:

* Norm Matloff, (and his group of students) who, in a SimPy performance
  improvement study, proposed removing the dictionary from the event list.

* Tony Vignaux, who proposed marking and subsequently ignoring cancelled
event notices.

* Klaus Müller, who found the Python package "heapq" to give the best event
list
  handling performance for a wide range of model types.

We want to thank all the SimPy users who helped with testing and profiling
the new event handler. 1.9 would not have been possible without out you!

=============================
Release notes for SimPy 1.9
============================= 

Additions
=========

- ``start``, a new method of activating processes.

- a standard identifier, ``ACTIONS`` for Process Execution methods
  to  allows a succinct use of ``start``.

- A method returning the time-weighted variance of observations 
  has been added to classes ``Monitor`` and ``Tally``.

- ``TheBank2`` tutorial has been extended to give a model of
  ``interrupt``.

Changes to code and documentation
================================= 

- The event scheduler has been completely re-designed to speed up 
  event handling. 

- The Manual has edited  to use a more readable notation.

Repairs
=======

- The tracing of ``activate`` statements by ``SimuLationTrace.py`` 
  has been enabled again.

------------------------------------------------------------------------
(end of Release Notes)

Enjoy!

Best wishes for happy, productive SimPying in 2008!

Klaus Muller    TonyVignaux     Bob Helmbold 

-------------------------------------------------------------------------
This SF.net email is sponsored by: Microsoft
Defy all challenges. Microsoft(R) Visual Studio 2005.
http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/

Mon	Tue	Wed	Thu	Fri	Sat	Sun

					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

8	February 2012
39	January 2012
23	December 2011
4	November 2011
9	October 2011
7	September 2011
25	August 2011
16	July 2011
25	June 2011
8	May 2011
10	April 2011
3	March 2011
9	February 2011
14	January 2011
14	December 2010
3	November 2010
19	October 2010
6	September 2010
5	August 2010
12	July 2010
22	June 2010
10	May 2010
10	April 2010
14	March 2010
30	February 2010
16	January 2010
9	December 2009
20	November 2009
16	October 2009
22	September 2009
6	August 2009
29	July 2009
2	June 2009
2	May 2009
19	April 2009
41	March 2009
2	February 2009
5	January 2009
1	December 2008
8	September 2008
43	August 2008
10	July 2008
3	June 2008
19	May 2008
17	April 2008
7	March 2008
11	February 2008
20	January 2008
4	December 2007
16	November 2007
15	October 2007
20	September 2007
11	August 2007
6	July 2007
17	June 2007
9	May 2007
23	April 2007
19	March 2007
25	February 2007
5	January 2007
13	December 2006
6	November 2006
24	October 2006
16	September 2006
2	August 2006
1	July 2006
5	June 2006
12	May 2006
17	April 2006
3	March 2006
8	February 2006
21	January 2006
41	December 2005
16	November 2005
12	October 2005
32	September 2005
8	August 2005
37	July 2005
2	June 2005
21	April 2005
28	March 2005
20	February 2005
17	January 2005
11	December 2004
10	November 2004
20	October 2004
6	September 2004