Store_plot

http://packages.python.org/SimPy/Manuals/Manual.html?highlight=inventory#stores

The Store object sObj is established by a statement like the following:

where

• • name (string type) is a descriptive name for sObj (e.g., 'Inventory').

  • unitName (string type) is a descriptive name for the items in sObj (e.g., 'widgets').

  • capacity (positive integer) is the maximum number of individual items that can be held in sObj. The default value is set to 'unbounded' which is interpreted as sys.maxint.

  • initialBuffered (a list of individual items) is sObj‘s initial content.

  • putQType (FIFO or PriorityQ) is the (producer) queue discipline.

  • getQType (FIFO or PriorityQ) is the (consumer) queue discipline.

  • monitored (boolean) specifies whether sObj‘s queues and contents are to be recorded.

  • monitorType (Monitor or Tally) specifies the type of Recorder to be used. Defaults to Monitor.

The Store object sObj also has the following additional attributes:

• • sObj.theBuffer is a queue (list) of the individual items in sObj. This list is in FIFO order unless the user stores them in a particular order (see Storing objects in an order , below). It is read-only and not directly changeable by the user.

  • sObj.nrBuffered is the current number of objects in sObj. This is read-only and not directly changeable by the user.

  • sObj.putQ is the queue of processes waiting to add items to sObj, so that len(sObj.putQ) is the number of processes waiting to add items.

  • sObj.getQ is the queue of processes waiting to get items from sObj, so that len(sObj.getQ) is the number of processes waiting to get items.

  • If sObj.monitored is True then the queues are to be recorded. In this case sObj.putQMon, sObj.getQMon, and sObj.bufferMon exist.

  • sObj.putQMon is a Recorder observing sObj.putQ.

  • sObj.getQMon is a Recorder observing sObj.getQ.

  • sObj.bufferMon is a Recorder observing sObj.nrBuffered.

Putting objects into a Store¶

Processes can request items from a Store and the same or other processes can offer items to it. First look at the simpler of these operations, the yield put.

A process, the offerer, which is usually but not necessarily different from the requester, can offer a list of items to sObj by a yield put statement:

• yield put,self,sObj,give[,P]

Here give is a list of any Python objects. If this statement would lead to an overflow (that is, sObj.nrBuffered + len(give) > sObj.capacity) the putting process is passivated and queued (in sObj.putQ) until there is sufficient room. P is an optional priority value (real or integer).

The ordering of processes in a Store’s putQ and getQ behave like those described for the waitQ under Resources , except that they are not preemptable. Thus, priority values are ignored when the queue type is FIFO. Otherwise higher priority values indicate higher priority, etc.

The items in sObj are stored in the form of a queue called sObj.theBuffer, which is in FIFO order unless the user has arranged to sort them into a particular order (see Storing objects in an order below).

Getting objects from a Store

There are two ways of getting objects from a Store. A process, the requester, can either extract the first n objects from sObj or a list of items chosen by a filter function.

Getting n items is achieved by the following statement:

• yield get,self,sObj,n [,P]

Here n must be a positive integer and P is an optional priority value (real or integer). If sObj does not currently hold enough objects to satisfy this request (that is, n >sObj.nrBuffered) then the requesting process is passivated and queued (in sObj.getQ). Subject to the priority ordering, it will be reactivated when the request can be satisfied.

The retrieved objects are returned in the list attribute got of the requesting process.

yield get requests with a numerical parameter are honored in priority/FIFO order. Thus, if there are two processes in the Store’s getQ, with the first requesting two items and the second one, the second process gets the requested item only after the first process has been given its two items.

Using the get filter function

The second method is to get a list of items chosen by a filter function, written by the user.

The command, using filter function ffn is as follows:

• yield get,self,sObj,ffn [,P]

The user provides a filter function that has a single list argument and returns a list. The argument represents the buffer of the Store. The function must search through the objects in the buffer and return a sub-list of those that satisfy the requirement.

Example The filter function allweight, shown below, is an example of such a filter. The argument, buff, will be automatically replaced in the execution of yieldget,self,store,allweight by the buffer of the Store. In this example the objects in the Store are assumed to have weight attributes. The function allweight selects all those that have a weight attribute over a value W and returns these as a list. The list appears to the calling process as self.got:

This might be used as follows:

yield get,self,sObj,allweight [,P]

The retrieved objects are returned in the list attribute got of the requesting process.

Note: ``yield get`` requests with a filter function parameter are not necessarily honored in priority/FIFO order, but rather according to the filter function. An example: There are two processes in the Store’s getQ, with the first requesting an item with a weight attribute less than 2 kilograms and the second one requesting one with a weight attribute less than 3 kilograms. If there is an item in the Store’s buffer with a weight attribute between 2 and 3 and none with an attribute of less than 2, the second get requester gets unblocked before the first one. Effectively, the SimPy run time system runs through all processes in the getQ in sequence and tests their filter functions as long as there are still items in the Store’s buffer.

Example The following program illustrates the use of a Store to model the production and consumption of “widgets”. The widgets are distinguished by their weight:

from SimPy.Simulation import *

from SimPy.SimPlot import *

class ProducerD(Process):

    def __init__(self):

        Process.__init__(self)

    def produce(self):           # the ProducerD PEM

        while True:

            yield put,self,buf,[Widget(9),Widget(7)]

            yield hold,self,10

class ConsumerD(Process):       

    def __init__(self):

        Process.__init__(self)

    def consume(self):           # the ConsumerD PEM

        while True:

            toGet=3

            yield get,self,buf,toGet

            assert len(self.got)==toGet

            print now(),'Get widget weights',\

                 [x.weight for x in self.got]

            yield hold,self,11

class Widget(Lister):

    def __init__(self,weight=0):

        self.weight=weight

widgbuf=[]

for i in range(10):

    widgbuf.append(Widget(5))

initialize()

buf=Store(capacity=11,initialBuffered=widgbuf,monitored=True)

for i in range(3):       # define and activate 3 producer objects

    p=ProducerD()

    activate(p,p.produce())

for i in range(3):       # define and activate 3 consumer objects

    c=ConsumerD()

    activate(c,c.consume())

simulate(until=50)

print 'LenBuffer:',buf.bufferMon     # length of buffer

print 'getQ:',buf.getQMon            # length of getQ

print 'putQ',buf.putQMon             # length of putQ

plt=SimPlot()

#plt.plotStep(buf.getQMon,color='blue')

#plt.plotStep(buf.putQMon,color='blue')

plt.plotStep(buf.bufferMon,color='blue')

plt.mainloop()

===========================================

0 Get widget weights [5, 5, 5]

0 Get widget weights [5, 5, 5]

0 Get widget weights [5, 5, 5]

11 Get widget weights [5, 9, 7]

11 Get widget weights [9, 7, 9]

11 Get widget weights [7, 9, 7]

22 Get widget weights [9, 7, 9]

22 Get widget weights [7, 9, 7]

22 Get widget weights [9, 7, 9]

33 Get widget weights [7, 9, 7]

33 Get widget weights [9, 7, 9]

40 Get widget weights [7, 9, 7]

44 Get widget weights [9, 7, 9]

50 Get widget weights [7, 9, 7]

LenBuffer: [[0, 10], [0, 7], [0, 9], [0, 11], [0, 8], [0, 10], [0, 7], [10, 9], [10, 11], [11, 8], [11, 10], [11, 7], [11, 4], [20, 6], [20, 8], [21, 10], [22, 7], [22, 4], [22, 1], [30, 3], [30, 5], [31, 7], [33, 4], [33, 1], [40, 3], [40, 0], [40, 2], [41, 4], [44, 1], [50, 3], [50, 0], [50, 2]]

getQ: [[0, 0], [33, 1], [40, 0], [44, 1], [50, 0]]

putQ [[0, 0], [0, 1], [0, 2], [0, 3], [0, 2], [0, 1], [0, 0], [10, 1], [11, 0]]

http://packages.python.org/SimPy/Manuals/PlotManual/ManualPlotting.html?highlight=simplot#SimPlot

plt.plotScatter(buf.bufferMon,color='blue')

plt.plotLine(buf.bufferMon,color='blue')