1
2 from SimPy.MonitorTest import *
3 from SimPy.SimulationStep import *
4 import sys
5 import unittest
6 from random import random
7
8 """testSimPyStep.py
9 SimPy version 2.0
10 Unit tests for SimulationStep.
11
12 **Change history:**
13 # 2002 11 15 Added tests for priority queues and preemption
14 # 2002 11 22 testing problem in accum
15 # 2003 03 30 added tests for SEP001v17 interrupts
16 # 2003 04 05 added test for interruptReset
17 # 2003 04 08 added tests for process state transitions
18 # 2003 04 10 changed to 'self.cancel(victim)' syntax
19 # 2003 04 13 removed dummy init assertions
20 # 2004 02 28 added test for monitored queues (gav)
21 # 2004 05 03 corrected test for monitored queues (gav)
22 # 2004 05 15 first version of testSimPyStep; just
23 # tests compatibility with SimulationStep.py
24 # 2004 09 17 added tests for waitevent, queueevent, waituntil (new in 1.5)
25 # 2005 05 19 added tests for compound yield statements (reneging)
26 # 2006 01 15 added tests for Store and Level and the get / put yield statements
27 # 2006 02 02 removed histogram plotting suite
28 # 2006 05 10 changed test testStatic for Level to test that float type
29 supported for initialBuffered
30 # 2006 05 16 added tests for Store and Level to test basic Producer / Consumer
31 principles
32 # 2006 10 16 added tests for compound get statement (Unmonitored Store / Level)
33 # 2006 10 17 added tests for compound put statement (Unmonitored Store / Level)
34 # 2007 01 08 added tests for monitoring of Store / Level with compound get / put
35 # 2007 01 08 added test for Store with filter function
36 # 2007 12 05 added tests for start method (Process)
37 # 2008 03 03 added test for nested preempts
38
39 #'$Revision: 264 $ $Date: 2009-03-22 15:33:21 +0100 (So, 22 Mrz 2009) $ kgm'
40
41 """
42 simulationStepVersion=version
43 print "Under test: SimulationStep.py %s"%simulationStepVersion
44 __version__ = '2.0 $Revision: 264 $ $Date: 2009-03-22 15:33:21 +0100 (So, 22 Mrz 2009) $ '
45 print 'testSimPyStepOO.py %s'%__version__
46
47
48
49
51 """ P class for testing"""
52 - def __init__(self,name="",T = 0,sim=None):
56
58 yield hold,self,self.T
59
61 """ PActions class for testing"""
62 - def __init__(self,name="",T = 0,sim=None):
66
68 yield hold,self,self.T
69
71 """ Tests of simulation
72 """
74 """Test initialisation
75 """
76 s=SimulationStep()
77 s.initialize()
78 result=s.simulate(until=10)
79 assert result=="SimPy: No activities scheduled",\
80 "There should have been no activities."
81 assert(now()==0),"time not 0"
82
92
102
112
114 """Test yield hold and simulate(until)
115 """
116 s=SimulationStep()
117 s.initialize()
118 P1 = P(name="P1",T=10,sim=s)
119 s.initialize()
120 s.activate(P1,P1.execute(),0)
121 s.simulate(until=5)
122 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
123
124 P2 = P(name="P2",T=10,sim=s)
125 s.initialize()
126 s.activate(P2,P2.execute(),0)
127 s.simulate(until=20)
128 assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
129
140
141
142
143
144
146 """ Job class for testing"""
147 - def __init__(self,server=None,name="",sim=None):
151
154
156 """ First simple tests of Resources
157 """
159 """Test initialisation"""
160 s=SimulationStep()
161 s.initialize()
162 R = Resource(sim=s)
163 assert R.name == "a_resource", "Not null name"
164 assert R.capacity == 1, "Not unit capacity"
165 assert R.unitName =="units", "Not the correct unit name"
166 R = Resource(name='',capacity=1,sim=s)
167 assert R.name == "", "Not null name"
168 assert R.capacity == 1, "Not unit capacity"
169 assert R.unitName =="units", "Not the correct unit name"
170 R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s)
171 assert R.name =="3-version" , "Wrong name, it is"+R.name
172 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
173 assert R.unitName =="blobs", "Not the correct unit name"
174
175 R = Resource(capacity=0,name="0-version",sim=s)
176 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
177
179 """Test request"""
180
181
182 R0 = Resource(name='',capacity=0)
183 assert R0.name == "", "Not null name"
184 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
185
186 s=SimulationStep()
187 s.initialize()
188 R1 = Resource(capacity=0,name="3-version",unitName="blobs")
189 J= Job(name="job",server=R1)
190 s.activate(J,J.execute(), at=0.0)
191
192 s.simulate(until=10.0)
193 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
194 lenW = len(R1.waitQ)
195 assert lenW==1,"Should be 1, it is "+str(lenW)
196 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
197 str(len(R1.activeQ))
198
200 """Test request2 with capacity = 1"""
201
202 s=SimulationStep()
203 s.initialize()
204 R2 = Resource(capacity=1,name="3-version",unitName="blobs")
205 J2= Job(name="job",server=R2)
206 s.activate(J2,J2.execute(), at=0.0)
207
208 s.simulate(until = 10.0)
209 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
210 lenW = len(R2.waitQ)
211 lenA = len(R2.activeQ)
212 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
213 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
214
216 """Test request3 with capacity = 1 several requests"""
217
218 s=SimulationStep()
219 s.initialize()
220 R3 = Resource(capacity=1,name="3-version",unitName="blobs")
221 J2= Job(name="job",server=R3)
222 J3= Job(name="job",server=R3)
223 J4= Job(name="job",server=R3)
224 s.activate(J2,J2.execute(), at=0.0)
225 s.activate(J3,J3.execute(), at=0.0)
226 s.activate(J4,J4.execute(), at=0.0)
227
228 s.simulate(until = 10.0)
229 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
230 lenW = len(R3.waitQ)
231 lenA = len(R3.activeQ)
232 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
233 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
234 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
235 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
236
238 """Test request4 with capacity = 2 several requests"""
239
240 s=SimulationStep()
241 s.initialize()
242 R3 = Resource(capacity=2,name="4-version",unitName="blobs")
243 J2= Job(name="job",server=R3)
244 J3= Job(name="job",server=R3)
245 J4= Job(name="job",server=R3)
246 s.activate(J2,J2.execute(), at=0.0)
247 s.activate(J3,J3.execute(), at=0.0)
248 s.activate(J4,J4.execute(), at=0.0)
249
250 s.simulate(until = 10.0)
251 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
252 lenW = len(R3.waitQ)
253 lenA = len(R3.activeQ)
254 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
255 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
256 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
257 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
258
259
260
262 """Test PriorityQ, with no preemption, 0 capacity"""
263 class Job(Process):
264 """ Job class for testing"""
265 def __init__(self,server=None,name="",sim=None):
266 Process.__init__(self,name,sim)
267 self.name=name
268 self.R=server
269
270 def execute(self,priority):
271 yield request,self,self.R,priority
272
273 s=SimulationStep()
274 s.initialize()
275 Rp = Resource(capacity=0,qType=PriorityQ,sim=s)
276 J5 = Job(name="job 5",server=Rp,sim=s)
277 J6 = Job(name="job 6",server=Rp,sim=s)
278 J7 = Job(name="job 7",server=Rp,sim=s)
279 s.activate(J5,J5.execute(priority=3))
280 s.activate(J6,J6.execute(priority=0))
281 s.activate(J7,J7.execute(priority=1))
282 s.simulate(until=100)
283 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
284 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
285
286 """Test PriorityQ mechanism"""
287
288 def sorted(q):
289 if not q or len(q) == 1:
290 sortok=1
291 return sortok
292 sortok = q[0] >= q[1] and sorted(q[2:])
293 return sortok
294
295 s=SimulationStep()
296 s.initialize()
297 Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
298 for i in range(10):
299 J=Job(name="job "+str(i),server=Rp,sim=s)
300 s.activate(J,J.execute(priority=random()))
301 s.simulate(until=1000)
302 qp=[x._priority[Rp] for x in Rp.waitQ]
303 assert sorted(qp),"waitQ not sorted by priority: %s"\
304 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
305
307 """Test PriorityQ, with no preemption, capacity == 1"""
308 class Job(Process):
309 """ Job class for testing"""
310 def __init__(self,server=None,name="",sim=None):
311 Process.__init__(self,name,sim)
312 self.name=name
313 self.R=server
314
315 def execute(self,priority):
316 yield request,self,self.R,priority
317
318 s=SimulationStep()
319 s.initialize()
320 Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
321 J5 = Job(name="job 5",server=Rp,sim=s)
322 J6 = Job(name="job 6",server=Rp,sim=s)
323 J7 = Job(name="job 7",server=Rp,sim=s)
324 s.activate(J5,J5.execute(priority=2))
325 s.activate(J6,J6.execute(priority=4))
326 s.activate(J7,J7.execute(priority=3))
327 s.simulate(until=100)
328 assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
329 %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
330
332 """Test PriorityQ, with preemption, capacity == 1"""
333 class nuJob(Process):
334 def __init__(self,name,sim=None):
335 Process.__init__(self,name,sim)
336
337 def execute(self,res,priority):
338 self.preempt=len(res.activeQ) > 0\
339 and priority > res.activeQ[-1]._priority[res]
340 t=self.sim.now()
341 yield request,self,res,priority
342 if self.preempt:
343 assert len(res.waitQ) == 1, \
344 "No preemption activeQ= %s"%res.activeQ[0].name
345 yield hold,self,30
346 t1=self.sim.now()
347 if self.preempt:
348 assert t+30 == t1,\
349 "Wrong completion time for preemptor %s"%self.name
350 else:
351 assert t+60 == t1,\
352 "Wrong completion time for preempted %s %s:"\
353 %(self.nameself.sim.now())
354 yield release,self,res
355
356 s = SimulationStep()
357 s.initialize()
358 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
359 sim=s)
360 n1=nuJob(name="nuJob 1",sim=s)
361 n2=nuJob(name="nuJob 2",sim=s)
362 s.activate(n1,n1.execute(res,priority=0))
363 s.activate(n2,n2.execute(res,priority=1),at=15)
364 s.simulate(until=100)
365
367 """Test preemption of preemptor"""
368 class nuJob(Process):
369 seqOut=[]
370 def __init__(self,name,sim=None):
371 Process.__init__(self,name,sim)
372 self.serviceTime=30
373
374 def execute(self,res,priority):
375 self.preempt=len(res.activeQ) > 0\
376 and priority > res.activeQ[-1]._priority[res]
377 nrwaiting=len(res.waitQ)
378 yield request,self,res,priority
379 if self.preempt:
380 assert len(res.waitQ) == nrwaiting + 1,\
381 "No preemption activeQ= %s"%res.activeQ[0].name
382 yield hold,self,self.serviceTime
383 yield release,self,res
384 nuJob.seqOut.append((self,self.sim.now()))
385
386 s=SimulationStep()
387 s.initialize()
388 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
389 sim=s)
390 n1=nuJob(name="nuJob 1",sim=s)
391 n2=nuJob(name="nuJob 2",sim=s)
392 n3=nuJob(name="nuJob 3",sim=s)
393 s.activate(n1,n1.execute(res,priority=-1))
394 start2=10
395 s.activate(n2,n2.execute(res,priority=0),at=start2)
396 start3=20
397 s.activate(n3,n3.execute(res,priority=1),at=start3)
398 s.simulate(until=100)
399 assert [x[1] for x in nuJob.seqOut]\
400 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
401 "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
402
404 """Test that a process can preempt another process holding multiple resources
405 """
406 class Requestor(Process):
407 def run(self,res1,res2,res3,priority=1):
408 yield request,self,res1,priority
409 yield request,self,res2,priority
410 yield request,self,res3,priority
411 record.observe(t=s.now(),y=self.name)
412 yield hold,self,100
413 record.observe(t=s.now(),y=self.name)
414 yield release,self,res3
415 yield release,self,res2
416 yield release,self,res1
417
418 s=SimulationStep()
419 s.initialize()
420 outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
421 inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
422 innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
423 sim=s)
424 record=Monitor(sim=s)
425 r1=Requestor("r1",sim=s)
426 s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
427 r2=Requestor("r2",sim=s)
428 s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
429 at=50)
430 s.simulate(until=200)
431 assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
432 "was %s; preempt did not work"%record
433
435 """ test monitoring of number in the two queues, waitQ and activeQ
436 """
437 class Job(Process):
438 def __init__(self,name,sim=None):
439 Process.__init__(self,name,sim)
440
441 def execute(self,res):
442 yield request,self,res
443 yield hold,self,2
444 yield release,self,res
445
446 s=SimulationStep()
447 s.initialize()
448 res=Resource(name="server",capacity=1,monitored=1,sim=s)
449 n1=Job(name="Job 1",sim=s)
450 n2=Job(name="Job 2",sim=s)
451 n3=Job(name="Job 3",sim=s)
452 s.activate(n1,n1.execute(res),at=2)
453 s.activate(n2,n2.execute(res),at=2)
454 s.activate(n3,n3.execute(res),at=2)
455 s.simulate(until=100)
456 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
457 'Wrong waitMon:%s'%res.waitMon
458 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
459 'Wrong actMon:%s'%res.actMon
460 self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/8.0,2,
461 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
462
464 suite = unittest.TestSuite()
465 testInit = makeResourcetestcase("testInit")
466 testrequest = makeResourcetestcase("testrequest")
467 testrequest2 = makeResourcetestcase("testrequest2")
468 testrequest3 = makeResourcetestcase("testrequest3")
469 testrequest4 = makeResourcetestcase("testrequest4")
470 testrequestPriority = makeResourcetestcase("testrequestPriority")
471 testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
472 testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
473 testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
474 testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
475 testmonitored = makeResourcetestcase("testmonitored")
476
477 suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
478 testrequestPriority,testrequestPriority1,
479 testrequestPriority2,testrequestPriority3,
480 testrequestNestedPreempt,
481 testmonitored])
482 return suite
483
484
485
486
487
491
492 - def breakin(self,waitbefore,howoften=1):
493 for i in range(howoften):
494 yield hold,self,waitbefore
495 self.interrupt(victim)
496
500
502 global igothit
503 igothit={}
504 while self.sim.now()<=theEnd:
505 yield hold,self,howlong
506 if self.interrupted():
507 byWhom=self.interruptCause
508 igothit[self.sim.now()]=byWhom
509 else:
510 pass
511
513 """
514 Tests interrupts as defined in SEP001v17
515 """
530
531
532
548
562
564 """
565 Test multiple interrupts by multiple processes during victim activity
566 """
567 global victim
568 s=SimulationStep()
569 s.initialize()
570 breaker1=Interruptor(sim=s)
571 s.activate(breaker1,breaker1.breakin(15,howoften=3))
572 breaker2=Interruptor(sim=s)
573 s.activate(breaker2,breaker2.breakin(20,howoften=3))
574 victim=Interrupted(sim=s)
575 s.activate(victim,victim.myActivity(100))
576 s.simulate(until=200)
577 for i in (15,30,45):
578 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
579 for i in (20,40,60):
580 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
581 assert len(igothit) == 6 , "Interrupted wrong number of times"
582
600
601 victim.newProcess=newProcess
602 s.activate(victim,newProcess(victim))
603 s.activate(breaker,breaker.breakin(10,howoften=3))
604 s.simulate(until=1000)
605
616
617
618
619
620
632
636
638 assert p.active(),"p not active"
639 assert not p.passive(), "p passive"
640 assert not p.terminated(),"p terminated"
641 assert not p.interrupted(),"p interrupted"
642 yield hold,self,11
643 assert not p.active(),"p active"
644 assert not p.passive(),"p passive"
645 assert p.terminated(),"p not terminated"
646 assert not p.interrupted(),"p interrupted"
647
649 assert not p.active(),"p active"
650 assert p.passive(),"p not passive"
651 assert not p.terminated(),"p not terminated"
652 assert not p.interrupted(),"p interrupted"
653 self.sim.activate(p,p.life1())
654 yield hold,self,11
655 assert not p.active(),"p active"
656 assert not p.passive(),"p not passive"
657 assert p.terminated(),"p not terminated"
658 assert not p.interrupted(),"p interrupted"
659
661 assert not p.active(),"p active"
662 assert p.passive(),"p not passive"
663 assert not p.terminated(),"p not terminated"
664 assert not p.interrupted(),"p interrupted"
665 self.sim.activate(p,p.life2())
666 yield hold,self,11
667 assert not p.active(),"p active"
668 assert p.passive(),"p not passive"
669 assert not p.terminated(),"p terminated"
670 assert not p.interrupted(),"p interrupted"
671
673 yield hold,self,5
674 assert p.active(),"p not active"
675 assert not p.passive(),"p passive"
676 assert not p.terminated(),"p terminated"
677 assert not p.interrupted(),"p interrupted"
678 self.cancel(p)
679 assert not p.active(),"p active"
680 assert p.passive(),"p not passive"
681 assert not p.terminated(),"p terminated"
682 assert not p.interrupted(),"p interrupted"
683 self.sim.reactivate(p)
684 assert p.active(),"p not active"
685 assert not p.passive(),"p passive"
686 assert not p.terminated(),"p terminated"
687 assert not p.interrupted(),"p interrupted"
688 yield hold,self
689 assert not p.active(),"p active"
690 assert not p.passive(),"p passive"
691 assert p.terminated(),"p terminated"
692 assert not p.interrupted(),"p interrupted"
693
695 yield hold,self,11
696 assert not p.active(),"p active"
697 assert p.passive(),"p not passive"
698 assert not p.terminated(),"p terminated"
699 assert not p.interrupted(),"p interrupted"
700 self.cancel(p)
701 assert not p.active(),"p active"
702 assert p.passive(),"p not passive"
703 assert not p.terminated(),"p terminated"
704 assert not p.interrupted(),"p interrupted"
705
723
727
728 - def look1(self,p1,p2,res):
729 assert p1.active(), "p1 not active"
730 assert not p1.queuing(res), "p1 queuing"
731 assert p2.active(), "p2 noit active"
732 assert not p2.queuing(res), "p2 queuing"
733 yield hold,self,2
734 assert p1.active(), "p1 not active"
735 assert not p1.queuing(res), "p1 queuing"
736 assert p2.passive(), "p2 active"
737 assert p2.queuing(res), "p2 not queuing"
738
747
749 """
750 Tests states and state transitions as defined in SEP003
751 """
752
765
784
806
808 """
809 Test request/release state transitions
810 """
811
812 s=SimulationStep()
813 s.initialize()
814 res=Resource(capacity=1,sim=s)
815 pq1=PS2(sim=s)
816 s.activate(pq1,pq1.life1(res))
817 pq2=PS2(sim=s)
818 s.activate(pq2,pq2.life1(res))
819 obq1=Observer2(sim=s)
820 s.activate(obq1,obq1.look1(pq1,pq2,res))
821 s.simulate(until=12)
822
823
824 s=SimulationStep()
825 s.initialize()
826 res=Resource(capacity=1,sim=s)
827 pq3=PS2(sim=s)
828 s.activate(pq3,pq3.life2(res))
829 obq2=Observer2(sim=s)
830 s.activate(obq2,obq2.look2(pq3,res),prior=True)
831 s.simulate(until=12)
832
842
843
844
845
846
851 yield hold,self,1
852 ev1.signal("from SignalProcess")
853 while ev2.queues:
854 nq0=len(ev2.queues)
855 ev2.signal("from SignalProcess")
856 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
857
862 yield waitevent,self,ev1
863 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
864 assert ev1 in self.eventsFired,"did not record firing event"
865
870 yield queueevent,self,ev2
871 assert ev2 in self.eventsFired,"did not record firing event"
872
875 yield hold,self,1
876 ev1.signal("from SignalProcess")
877 yield hold,self,3
878 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
879 while ev2.queues:
880 nq0=len(ev2.queues)
881 ev2.signal("from SignalProcess")
882 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
883 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
884
889 yield waitevent,self,evset
890 for e in evset:
891 assert e.waits==[],"process not out of waiting list for all events in OR"
892
903
904
906 nrProcesses=0
911 yield queueevent,self,evset
912 occurred=False
913 for e in evset:
914 occurred=occurred or (e in self.eventsFired)
915 assert occurred,"queuing process activated by wrong event(s)"
916
921 e1=SimEvent()
922 e1.signal()
923 e2=SimEvent()
924 e2.signal()
925 yield queueevent,self,[e1,e2]
926 assert self.eventsFired==[e1,e2],\
927 "(queueevent) eventsFired does not report all fired events"
928
930 """
931 Test SimEvent/signal as introduced with SimPy 1.5
932 """
933
935 """
936 Tests basic signal semantics
937 """
938 s=SimulationStep()
939 s.initialize()
940 e=SimEvent(sim=s)
941 e.signal("param")
942 assert e.occurred,"signal does not set 'occurred' to True"
943 assert e.signalparam=="param","signal parameter wrong"
944 e.signal()
945 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
946 e.signal()
947 assert e.occurred,"multiple calls to signal do not set 'occurred'"
948
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
984 """
985 Tests waiting, queuing for at least one event out of a list/tuple.
986 """
987 si=SimulationStep()
988 si.initialize()
989 e1=SimEvent("e1",sim=si)
990 e2=SimEvent("e2",sim=si)
991 e3=SimEvent("e3",sim=si)
992 s=SignalProcessOR(sim=si)
993 si.activate(s,s.makeSignal(e1,e3))
994 w=WaitProcessOR(sim=si)
995 si.activate(w,w.waitForSig([e1,e2]))
996 for i in range(5):
997 q=QueueProcessOR(sim=si)
998 si.activate(q,q.queueForSig([e2,e3]))
999 si.simulate(until=10)
1000
1009
1018
1029
1030
1031
1032
1033
1038 global a,b,c
1039 a=True
1040 yield hold,self,1
1041 b=True
1042 yield hold,self,1
1043 c=True
1044 yield hold,self,1
1045 assert waiter.terminated(),"waituntil did not fire"
1046
1051 def waitcond():
1052 return a and b and c
1053 yield waituntil,self,waitcond
1054
1056 """
1057 Test waituntil as introduced with SimPy 1.5
1058 """
1059
1070
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1088 """ Job class for testing timeout reneging
1089 """
1090 - def __init__(self,server=None,name="",sim=None):
1094
1095 - def execute(self,timeout,usetime):
1096 yield (request,self,self.res),(hold,self,timeout)
1097 if self.acquired(self.res):
1098 self.gotResource=True
1099 yield hold,self,usetime
1100 yield release,self,self.res
1101 else:
1102 self.gotResource=False
1103
1105 """ Job class for testing timeout reneging with priorities
1106 """
1107 - def __init__(self,server=None,name="",sim=None):
1111
1112 - def execute(self,timeout,usetime,priority):
1113 yield (request,self,self.res,priority),(hold,self,timeout)
1114 if self.acquired(self.res):
1115 self.gotResource=True
1116 yield hold,self,usetime
1117 yield release,self,self.res
1118 else:
1119 self.gotResource=False
1120
1122 """ Tests of "yield (request,self,res),(hold,self,delay)"
1123 timeout reneging command
1124 """
1126 """Test that resource gets acquired without timeout
1127 """
1128
1129 s=SimulationStep()
1130 s.initialize()
1131 res=Resource(name="Server",capacity=1,sim=s)
1132 usetime=5
1133 timeout=1000000
1134 j1=JobTO(server=res,name="Job_1",sim=s)
1135 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1136 j2=JobTO(server=res,name="Job_2",sim=s)
1137 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1138 s.simulate(until=2*usetime)
1139 assert s.now()==2*usetime,"time not ==2*usetime"
1140 assert j1.gotResource and j2.gotResource,\
1141 "at least one job failed to get resource"
1142 assert not (res.waitQ or res.activeQ),\
1143 "job waiting or using resource"
1144
1146 """Test that resource gets acquired without timeout.
1147 Resource monitored.
1148 """
1149
1150 s=SimulationStep()
1151 s.initialize()
1152 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1153 usetime=5
1154 timeout=1000000
1155 j1=JobTO(server=res,name="Job_1",sim=s)
1156 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1157 j2=JobTO(server=res,name="Job_2",sim=s)
1158 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1159 s.simulate(until=2*usetime)
1160 assert s.now()==2*usetime,"time not ==2*usetime"
1161 assert j1.gotResource and j2.gotResource,\
1162 "at least one job failed to get resource"
1163 assert not (res.waitQ or res.activeQ),\
1164 "job waiting or using resource"
1165 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1166
1168 """Test that timeout occurs when resource busy
1169 """
1170
1171 s=SimulationStep()
1172 s.initialize()
1173 res=Resource(name="Server",capacity=1,sim=s)
1174 usetime=5
1175 timeout=3
1176 j1=JobTO(server=res,name="Job_1",sim=s)
1177 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1178 j2=JobTO(server=res,name="Job_2",sim=s)
1179 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1180 s.simulate(until=2*usetime)
1181 assert(s.now()==usetime),"time not ==usetime"
1182 assert(j1.gotResource),"Job_1 did not get resource"
1183 assert(not j2.gotResource),"Job_2 did not renege"
1184 assert not (res.waitQ or res.activeQ),\
1185 "job waiting or using resource"
1186
1188 """Test that timeout occurs when resource busy.
1189 Resource monitored.
1190 """
1191 s=SimulationStep()
1192 s.initialize()
1193 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1194 usetime=5
1195 timeout=3
1196 j1=JobTO(server=res,name="Job_1",sim=s)
1197 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1198 j2=JobTO(server=res,name="Job_2",sim=s)
1199 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1200 s.simulate(until=2*usetime)
1201 assert(s.now()==usetime),"time not == usetime"
1202 assert(j1.gotResource),"Job_1 did not get resource"
1203 assert(not j2.gotResource),"Job_2 did not renege"
1204 assert not (res.waitQ or res.activeQ),\
1205 "job waiting or using resource"
1206 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1207
1209 """Test that timeout occurs when resource busy.
1210 Resource monitored. Requests with priority and preemption.
1211 """
1212 s=SimulationStep()
1213 s.initialize()
1214 res=Resource(name="Server",capacity=1,monitored=True,
1215 qType=PriorityQ,preemptable=True,sim=s)
1216 usetime=5
1217 timeout=3
1218 j1=JobTO_P(server=res,name="Job_1",sim=s)
1219 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1220 j2=JobTO_P(server=res,name="Job_2",sim=s)
1221 j2_arrival=1
1222 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
1223 at=j2_arrival)
1224 j3=JobTO_P(server=res,name="Job_2",sim=s)
1225 j3_arrival=2
1226 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
1227 at=j3_arrival)
1228 s.simulate(until=3*usetime)
1229 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1230 assert(j1.gotResource),"Job_1 did not get resource"
1231 assert(j2.gotResource),"Job_2 did renege"
1232 assert(j2.gotResource),"Job_3 did renege"
1233 assert not (res.waitQ or res.activeQ),\
1234 "job waiting or using resource"
1235 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1236 "res.waitMon wrong: %s"%res.waitMon
1237
1239 """Test that timeout occurs when resource has no capacity free
1240 """
1241
1242 s=SimulationStep()
1243 s.initialize()
1244 res=Resource(name="Server",capacity=0,sim=s)
1245 usetime=5
1246 timeout=3
1247 j1=JobTO(server=res,name="Job_1",sim=s)
1248 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1249 j2=JobTO(server=res,name="Job_2",sim=s)
1250 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1251 s.simulate(until=2*usetime)
1252 assert s.now()==timeout,"time %s not == timeout"%now()
1253 assert not j1.gotResource,"Job_1 got resource"
1254 assert not j2.gotResource,"Job_2 got resource"
1255 assert not (res.waitQ or res.activeQ),\
1256 "job waiting or using resource"
1257
1259 """Test that timeout occurs when resource has no capacity free.
1260 Resource monitored.
1261 """
1262
1263 s=SimulationStep()
1264 s.initialize()
1265 res=Resource(name="Server",capacity=0,monitored=True,sim=s)
1266 usetime=5
1267 timeout=3
1268 j1=JobTO(server=res,name="Job_1",sim=s)
1269 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1270 j2=JobTO(server=res,name="Job_2",sim=s)
1271 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1272 s.simulate(until=2*usetime)
1273 assert s.now()==timeout,"time %s not == timeout"%now()
1274 assert not j1.gotResource,"Job_1 got resource"
1275 assert not j2.gotResource,"Job_2 got resource"
1276 assert not (res.waitQ or res.activeQ),\
1277 "job waiting or using resource"
1278 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1279 "res.waitMon is wrong: %s"%res.waitMon
1280
1294
1295
1296
1297
1298
1299
1300
1301
1303 """ Job class for testing event reneging
1304 """
1305 - def __init__(self,server=None,name="",sim=None):
1309
1311 yield (request,self,self.res),(waitevent,self,event)
1312 if self.acquired(self.res):
1313 self.gotResource=True
1314 yield hold,self,usetime
1315 yield release,self,self.res
1316 else:
1317 self.gotResource=False
1318
1320 """ Job class for testing event reneging with multi-event lists
1321 """
1322 - def __init__(self,server=None,name="",sim=None):
1326
1327 - def execute(self,eventlist,usetime):
1328 yield (request,self,self.res),(waitevent,self,eventlist)
1329 if self.acquired(self.res):
1330 self.gotResource=True
1331 yield hold,self,usetime
1332 yield release,self,self.res
1333 else:
1334 self.gotResource=False
1335
1337 """Fires reneging event
1338 """
1341 - def fire(self,fireDelay,event):
1342 yield hold,self,fireDelay
1343 event.signal()
1344
1346 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1347 event reneging command
1348 """
1350 """Test that processes acquire resource normally if no event fires
1351 """
1352 s=SimulationStep()
1353 s.initialize()
1354 event=SimEvent("Renege_trigger",sim=s)
1355 res=Resource(name="Server",capacity=1,sim=s)
1356 usetime=5
1357 j1=JobEvt(server=res,name="Job_1",sim=s)
1358 s.activate(j1,j1.execute(event=event,usetime=usetime))
1359 j2=JobEvt(server=res,name="Job_2",sim=s)
1360 s.activate(j2,j2.execute(event=event,usetime=usetime))
1361 s.simulate(until=2*usetime)
1362
1363 assert s.now()==2*usetime,"time not ==2*usetime"
1364 assert j1.gotResource and j2.gotResource,\
1365 "at least one job failed to get resource"
1366 assert not (res.waitQ or res.activeQ),\
1367 "job waiting or using resource"
1368
1370 """Test that processes acquire resource normally if no event fires.
1371 Resource monitored.
1372 """
1373 s=SimulationStep()
1374 s.initialize()
1375 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1376 event=SimEvent("Renege_trigger",sim=s)
1377 usetime=5
1378 j1=JobEvt(server=res,name="Job_1",sim=s)
1379 s.activate(j1,j1.execute(event=event,usetime=usetime))
1380 j2=JobEvt(server=res,name="Job_2",sim=s)
1381 s.activate(j2,j2.execute(event=event,usetime=usetime))
1382 s.simulate(until=2*usetime)
1383
1384 assert s.now()==2*usetime,"time not ==2*usetime"
1385 assert j1.gotResource and j2.gotResource,\
1386 "at least one job failed to get resource"
1387 assert not (res.waitQ or res.activeQ),\
1388 "job waiting or using resource"
1389 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1390
1392 """Test that signalled event leads to renege when resource busy
1393 """
1394
1395 s=SimulationStep()
1396 s.initialize()
1397 res=Resource(name="Server",capacity=1,sim=s)
1398 event=SimEvent("Renege_trigger",sim=s)
1399 usetime=5
1400 eventtime=1
1401 j1=JobEvt(server=res,name="Job_1",sim=s)
1402 s.activate(j1,j1.execute(event=event,usetime=usetime))
1403 j2=JobEvt(server=res,name="Job_2",sim=s)
1404 s.activate(j2,j2.execute(event=event,usetime=usetime))
1405 f=FireEvent(name="FireEvent",sim=s)
1406 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1407 s.simulate(until=2*usetime)
1408
1409 assert(s.now()==usetime),"time not ==usetime"
1410 assert(j1.gotResource),"Job_1 did not get resource"
1411 assert(not j2.gotResource),"Job_2 did not renege"
1412 assert not (res.waitQ or res.activeQ),\
1413 "job waiting or using resource"
1414
1416 """Test that signalled event leads to renege when resource busy.
1417 Resource monitored.
1418 """
1419
1420 s=SimulationStep()
1421 s.initialize()
1422 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1423 event=SimEvent("Renege_trigger",sim=s)
1424 usetime=5
1425 eventtime=1
1426 j1=JobEvt(server=res,name="Job_1",sim=s)
1427 s.activate(j1,j1.execute(event=event,usetime=usetime))
1428 j2=JobEvt(server=res,name="Job_2",sim=s)
1429 s.activate(j2,j2.execute(event=event,usetime=usetime))
1430 f=FireEvent(name="FireEvent",sim=s)
1431 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1432 s.simulate(until=2*usetime)
1433
1434 assert(s.now()==usetime),"time not ==usetime"
1435 assert(j1.gotResource),"Job_1 did not get resource"
1436 assert(not j2.gotResource),"Job_2 did not renege"
1437 assert not (res.waitQ or res.activeQ),\
1438 "job waiting or using resource"
1439 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1440
1442 """Test that renege-triggering event can be one of an event list
1443 """
1444
1445 s=SimulationStep()
1446 s.initialize()
1447 res=Resource(name="Server",capacity=1,sim=s)
1448 event1=SimEvent("Renege_trigger_1",sim=s)
1449 event2=SimEvent("Renege_trigger_2",sim=s)
1450 usetime=5
1451 eventtime=1
1452 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1453 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1454 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1455 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1456 f1=FireEvent(name="FireEvent_1",sim=s)
1457 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1458 f2=FireEvent(name="FireEvent_2",sim=s)
1459 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1460 s.simulate(until=2*usetime)
1461
1462 assert(s.now()==usetime),"time not ==usetime"
1463 assert(j1.gotResource),"Job_1 did not get resource"
1464 assert(not j2.gotResource),"Job_2 did not renege"
1465 assert not (res.waitQ or res.activeQ),\
1466 "job waiting or using resource"
1467
1469 """Test that renege-triggering event can be one of an event list.
1470 Resource monitored.
1471 """
1472
1473 s=SimulationStep()
1474 s.initialize()
1475 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1476 event1=SimEvent("Renege_trigger_1",sim=s)
1477 event2=SimEvent("Renege_trigger_2",sim=s)
1478 usetime=5
1479 eventtime=1
1480 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1481 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1482 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1483 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1484 f1=FireEvent(name="FireEvent_1",sim=s)
1485 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1486 f2=FireEvent(name="FireEvent_2",sim=s)
1487 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1488 s.simulate(until=2*usetime)
1489
1490 assert(s.now()==usetime),"time not ==usetime"
1491 assert(j1.gotResource),"Job_1 did not get resource"
1492 assert(not j2.gotResource),"Job_2 did not renege"
1493 assert not (res.waitQ or res.activeQ),\
1494 "job waiting or using resource"
1495 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1496
1509
1510
1511
1512
1513
1514
1516 produced=0
1525 """PriorityQ for Producers"""
1526 Producer.produced+=4
1527 yield put,self,buffer,4,priority
1528 yield hold,self,1
1529 self.done=self.sim.now()
1530 doneList.append(self.name)
1532 for i in range(4):
1533 yield put,self,buffer,4
1534 yield hold,self,1
1536 consumed=0
1540 """FIFO"""
1541 yield get,self,buffer
1542 Consumer.consumed+=1
1543 assert self.got==1,"wrong self.got: %s"%self.got
1544 yield get,self,buffer,3
1545 Consumer.consumed+=3
1546 assert self.got==3,"wrong self.got: %s"%self.got
1547
1549 """producer PriorityQ, consumer FIFO"""
1550 while True:
1551 yield get,self,buffer,2
1552 yield hold,self,1
1554 """PriorityQ for Consumers"""
1555 yield get,self,buffer,4,priority
1556 doneList.append(self.name)
1557
1558
1562 - def produce(self,buffer,productionTime):
1563 while True:
1564 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1565 "Consumer(s) waiting while buffer not empty"
1566 yield hold,self,productionTime
1567 yield put,self,buffer,1
1568
1572 - def consume(self,buffer,consumptionTime):
1573 while True:
1574 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1575 "Producer(s) waiting while buffer empty"
1576 yield get,self,buffer,1
1577 yield hold,self,consumptionTime
1578
1579
1580
1583 """Tests initialization of Level instances
1584 """
1585 s=SimulationStep()
1586 s.initialize()
1587 a=Level(sim=s)
1588 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1589 assert a.amount==0,"wrong buffer content: %s"%a
1590 assert a.name=="a_level","wrong name: %s"%a
1591 assert not a.monitored,"should not be monitored: %s"%a
1592 assert a.putQMon is None,"should not have putQMon: %s"%a
1593 assert a.getQMon is None,"should not have getQMon: %s"%a
1594 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1595 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1596 "putQType and getQType should be FIFO: %s"%a
1597
1598 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1599 putQType=PriorityQ,sim=s)
1600 a=Level(sim=s)
1601 assert b.capacity==12,"wrong capacity:%s"%b
1602 assert b.amount==10,"wrong buffer content: %s"%b
1603 assert b.name=="b","wrong name: %s"%b
1604 assert b.monitored,"should be monitored: %s"%b
1605 assert not (b.putQMon is None),"should have putQMon: %s"%b
1606 assert not (b.getQMon is None),"should have getQMon: %s"%b
1607 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1608 assert b.putQType.__name__=="PriorityQ",\
1609 "putQType should be PriorityQ: %s"%b
1610 assert b.getQType.__name__=="FIFO",\
1611 "getQType should be PriorityQ: %s"%b
1612
1614 """Level: tests basic Producer/Consumer principles:
1615 - Consumers must not be waiting while Level buffer value > 0,
1616 - Producers must not be waiting while Level buffer value == 0
1617 """
1618 s=SimulationStep()
1619 s.initialize()
1620 bufferSize=1
1621 productionTime=1
1622 consumptionTime=5
1623 endtime=50
1624 buffer=Level(capacity=bufferSize,sim=s)
1625 consumer=ConsumerPrincL(sim=s)
1626 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1627 producer=ProducerPrincL(sim=s)
1628 s.activate(producer,producer.produce(buffer,productionTime))
1629 s.simulate(until=endtime)
1630
1644
1662
1664 """Level: tests put/get in multiple Producer/Consumer scenario,
1665 with Producers having different priorities.
1666 How: Producers forced to queue; all after first should be done in
1667 priority order
1668 """
1669 global doneList
1670 doneList=[]
1671 s=SimulationStep()
1672 s.initialize()
1673 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1674 for i in range(4):
1675 p=Producer(i,sim=s)
1676 pPriority=i
1677 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1678 c=Consumer(sim=s)
1679 s.activate(c,c.consume1(buffer=buffer))
1680 s.simulate(until=100)
1681 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1682 %doneList
1683
1685 """Level: tests put/get in multiple Producer/Consumer scenario, with
1686 Consumers having different priorities.
1687 How: Consumers forced to queue; all after first should be done in
1688 priority order
1689 """
1690 global doneList
1691 doneList=[]
1692 s=SimulationStep()
1693 s.initialize()
1694 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1695 for i in range(4):
1696 c=Consumer(i,sim=s)
1697 cPriority=i
1698 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1699 p=Producer(sim=s)
1700 s.activate(p,p.produce1(buffer=buffer))
1701 s.simulate(until=100)
1702 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\
1703 %doneList
1704
1716
1717
1718
1719
1720
1721
1722
1747
1775
1779
1781 """Sorts Widget instances by weight attribute."""
1782 tmplist=[(x.weight,x) for x in par]
1783 tmplist.sort()
1784 return [x for (key,x) in tmplist]
1785
1786
1790 - def produce(self,buffer,productionTime):
1791 while True:
1792 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1793 "Consumer(s) waiting while buffer not empty"
1794 yield hold,self,productionTime
1795 product=WidgetPrinc()
1796 yield put,self,buffer,[product]
1797
1801 - def consume(self,buffer,consumptionTime):
1802 while True:
1803 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1804 "Producer(s) waiting while buffer empty"
1805 yield get,self,buffer,1
1806 yield hold,self,consumptionTime
1807
1810
1812 """Used in testBufferFilter"""
1818
1820 """get all items with weight between a and b"""
1821 def between_a_and_b(buf):
1822 res=[]
1823 for item in buf:
1824 if a<item.weight<b:
1825 res.append(item)
1826
1827 all=store.buffered
1828 yield get,self,store,between_a_and_b
1829 "All retrieved items weight in range?"
1830 for it in self.got:
1831 assert a<it.weight<b,"weight %s not in range %s..%s"\
1832 %(it.weight,a,b)
1833 "Any item fitting filter pred left in buffer?"
1834 for it in store.buffer:
1835 assert not (a<it.weight<b),\
1836 "item left in buffer which fits filter (%s<%s<%s)"\
1837 %(a,it.weight,b)
1838 "All items either in store.buffer of self.got?"
1839 for it in all:
1840 assert (it in self.buffer) or (it in self.got),\
1841 "item w. weight %s neither in store nor in got"%it.weight
1842
1843
1844
1847 """Store: tests initialization of Store instances
1848 """
1849 s=SimulationStep()
1850 s.initialize()
1851 a=Store(sim=s)
1852 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1853 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1854 assert a.name=="a_store","wrong name: %s"%a
1855 assert not a.monitored,"should not be monitored: %s"%a
1856 assert a.putQMon is None,"should not have putQMon: %s"%a
1857 assert a.getQMon is None,"should not have getQMon: %s"%a
1858 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1859 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1860 "putQType and getQType should be FIFO: %s"%a
1861
1862 stored=[Widget(weight=5)]*10
1863 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1864 putQType=PriorityQ,sim=s)
1865 assert b.capacity==12,"wrong capacity:%s"%b
1866 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1867 assert b.name=="b","wrong name: %s"%b
1868 assert b.monitored,"should be monitored: %s"%b
1869 assert not (b.putQMon is None),"should have putQMon: %s"%b
1870 assert not (b.getQMon is None),"should have getQMon: %s"%b
1871 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1872 assert b.putQType.__name__=="PriorityQ",\
1873 "putQType should be PriorityQ: %s"%b
1874 assert b.getQType.__name__=="FIFO",\
1875 "getQType should be PriorityQ: %s"%b
1876
1878 """Store: tests basic Producer/Consumer principles:
1879 - Consumers must not be waiting while items in Store buffer,
1880 - Producers must not be waiting while space available in Store buffer
1881 """
1882 bufferSize=1
1883 productionTime=1
1884 consumptionTime=5
1885 endtime=50
1886 s=SimulationStep()
1887 s.initialize()
1888 buffer=Store(capacity=bufferSize,sim=s)
1889 consumer=ConsumerPrincS(sim=s)
1890 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1891 producer=ProducerPrincS(sim=s)
1892 s.activate(producer,producer.produce(buffer,productionTime))
1893 s.simulate(until=endtime)
1894
1909
1927
1929 """Store: Tests put/get in multiple Producer/Consumer scenario,
1930 with Producers having different priorities.
1931 How; Producers forced to queue; all after first should be done in
1932 priority order
1933 """
1934 global doneList
1935 doneList=[]
1936 s=SimulationStep()
1937 s.initialize()
1938 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1939 for i in range(4):
1940 p=ProducerWidget(name=i,sim=s)
1941 pPriority=i
1942 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1943 c=ConsumerWidget(sim=s)
1944 s.activate(c,c.consume1(buffer=buffer))
1945 s.simulate(until=100)
1946 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1947 %doneList
1948
1950 """Tests put/get in multiple Producer/Consumer scenario, with
1951 Consumers having different priorities.
1952 How; Consumers forced to queue; all after first should be done in
1953 priority order
1954 """
1955 global doneList
1956 doneList=[]
1957 s=SimulationStep()
1958 s.initialize()
1959 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1960 for i in range(4):
1961 c=ConsumerWidget(name=str(i),sim=s)
1962 cPriority=i
1963 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1964 p=ProducerWidget(sim=s)
1965 s.activate(p,p.produce1(buffer=buffer))
1966 s.simulate(until=100)
1967 assert doneList==["3","2","1","0"],\
1968 "gets were not done in priority order: %s"%doneList
1969
1971 """Tests the optional sorting of theBuffer by applying a user-defined
1972 sort function."""
1973 s=SimulationStep()
1974 s.initialize()
1975 gotten=[]
1976 sortedStore=Store(sim=s)
1977 sortedStore.addSort(mySortFunc)
1978 p=ProducerWidget(sim=s)
1979 s.activate(p,p.produceUnordered(sortedStore))
1980 for i in range(9):
1981 c=ConsumerWidget(sim=s)
1982 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
1983 s.simulate(until=10)
1984 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1985
1998
2013
2014
2015
2016
2017
2018
2019 -class TBT(Process):
2020 """Store: For testBasicTime"""
2023 - def tbt(self,store):
2024 yield get,self,store,1
2025 assert self.got,"Did not get Item"
2026 yield (get,self,store,1),(hold,self,5)
2027 if self.acquired(store):
2028 assert len(self.got)==1,"did not get 1 Item"
2029 else:
2030 assert not self.got and self.sim.now()==5 and not store.getQ,\
2031 "time renege not working"
2032
2033 -class TBE(Process):
2034 """Store: For testBasicEvent"""
2037 - def tbe(self,store,trigger):
2038 yield get,self,store,1
2039 assert self.got,"Did not get Item"
2040 yield (get,self,store,1),(waitevent,self,trigger)
2041 if self.acquired(store):
2042 assert False, "should have reneged"
2043 else:
2044 assert self.eventsFired[0]==trigger and self.sim.now()==5 \
2045 and not store.getQ,"event renege not working"
2046
2048 """Store: For testBasicEvent"""
2051 - def fire(self,trigger):
2054
2055
2057 """Store: for testBasicTimePut"""
2060 - def tbt(self,store):
2061 class Item:pass
2062 yield (put,self,store,[Item()]),(hold,self,4)
2063 if self.stored(store):
2064 assert store.nrBuffered==1 and not store.putQ,\
2065 "put did not execute"
2066 else:
2067 assert False,"should not have reneged"
2068 yield (put,self,store,[Item()]),(hold,self,5)
2069 if self.stored(store):
2070 assert False,"should have reneged"
2071 else:
2072 assert store.nrBuffered==1 and not store.putQ,\
2073 "renege not working correctly"
2074
2076 """Store: for testBasicEventPut"""
2079 - def tbe(self,store,trigger):
2080 class Item:pass
2081 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2082 if self.stored(store):
2083 assert store.nrBuffered==1 and not store.putQ,\
2084 "put did not execute"
2085 else:
2086 assert False,"should have not have reneged"
2087 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2088 if self.stored(store):
2089 assert False,"should have reneged"
2090 else:
2091 assert self.sim.now()==5 and self.eventsFired[0]==trigger\
2092 and not store.putQ,"renege not working correctly"
2093
2095 """Store: For testBasicEventPut"""
2098 - def fire(self,trigger):
2101
2103 """Store: Testcase for compound get statements"""
2104
2105
2106
2107
2108
2109
2120
2121
2122
2123
2124
2125
2135
2137 """Store (monitored):
2138 test monitors with 'yield (put,self,store),(hold,self,time)"""
2139 s=SimulationStep()
2140 s.initialize()
2141 st=Store(capacity=1,monitored=True,sim=s)
2142 t=TBTput(sim=s)
2143 s.activate(t,t.tbt(store=st))
2144 s.simulate(until=10)
2145
2146 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2147 %st.putQMon
2148
2149 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2150
2151
2152
2153
2154
2155
2169
2170
2171
2172
2173
2174
2187
2189 """Store (monitored):
2190 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2191 si=SimulationStep()
2192 si.initialize()
2193 s=SimEvent(sim=si)
2194 st=Store(capacity=1,monitored=True,sim=si)
2195 t=TBEtriggerPut(sim=si)
2196 si.activate(t,t.fire(trigger=s))
2197 tb=TBEput(sim=si)
2198 si.activate(tb,tb.tbe(store=st,trigger=s))
2199 si.simulate(until=10)
2200
2201 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2202 %st.putQMon
2203
2204 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2205
2221
2222
2223
2224
2225
2226
2228 """Level: For testBasicTime"""
2231 - def tbt(self,level):
2232 yield get,self,level,1
2233 assert self.got,"did not get 1 unit"
2234 yield (get,self,level,1),(hold,self,5)
2235 if self.acquired(level):
2236 assert self.got==1,"did not get 1 unit"
2237 else:
2238 assert not self.got and self.sim.now()==5,\
2239 "time renege not working"
2240
2242 """Level: For testBasicEvent"""
2245 - def tbe(self,level,trigger):
2246 yield get,self,level,1
2247 assert self.got,"did not get 1 unit"
2248 yield (get,self,level,1),(waitevent,self,trigger)
2249 if self.acquired(level):
2250 assert self.got==1,"did not get 1 Item"
2251 else:
2252 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
2253 "event renege not working"
2254
2256 """Level: For testBasicEvent"""
2259 - def fire(self,trigger):
2262
2264 """Level: For testBasicTimePut"""
2267 - def tbt(self,level):
2268 yield put,self,level,1
2269 assert level.amount,"did not put 1 unit"
2270 yield (put,self,level,1),(hold,self,5)
2271 if self.stored(level):
2272 assert False,"should have reneged"
2273 else:
2274 assert level.amount==1 and self.sim.now()==5,\
2275 "time renege not working"
2276
2278 """Level: For testBasicEventPut and testBasicEventPutM"""
2281 - def tbe(self,level,trigger):
2282 yield (put,self,level,1),(waitevent,self,trigger)
2283 if self.stored(level):
2284 assert level.amount==1,"did not put 1 unit"
2285 else:
2286 assert False,"should not have reneged"
2287 yield (put,self,level,1),(waitevent,self,trigger)
2288 if self.stored(level):
2289 assert False, "should have reneged"
2290 else:
2291 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
2292 "renege not working"
2293
2295 """Level: For testBasicEventPut"""
2298 - def fire(self,trigger):
2301
2303 """Level: Testcase for compound get and put statements"""
2304
2305
2306
2307
2308
2309
2320
2321
2322
2323
2324
2325
2335
2336
2337
2338
2339
2340
2353
2355 """Level (monitored):
2356 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2357 s=SimulationStep()
2358 s.initialize()
2359 l=Level(initialBuffered=1,monitored=True,sim=s)
2360 trig=SimEvent(sim=s)
2361 t=TBELev(sim=s)
2362 s.activate(t,t.tbe(level=l,trigger=trig))
2363 tr=TBEtriggerLev(sim=s)
2364 s.activate(tr,tr.fire(trigger=trig))
2365 s.simulate(until=10)
2366
2367 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2368 %l.getQMon
2369
2370 assert l.bufferMon==[[0,1],[0,0]],\
2371 "bufferMon not working: %s"%l.bufferMon
2372
2373
2374
2375
2376
2377
2390
2392 """Level (monitored):
2393 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2394 s=SimulationStep()
2395 s.initialize()
2396 l=Level(capacity=1,monitored=True,sim=s)
2397 trig=SimEvent(sim=s)
2398 t=TBELevPut(sim=s)
2399 s.activate(t,t.tbe(level=l,trigger=trig))
2400 tr=TBEtriggerLevPut(sim=s)
2401 s.activate(tr,tr.fire(trigger=trig))
2402 s.simulate(until=10)
2403 "First put succeeds, second reneges at t=5.5?"
2404 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2405 %l.putQMon
2406 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2407 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2408
2423
2424 if __name__ == '__main__':
2425 alltests = unittest.TestSuite((
2426 makeSSuite(),
2427 makeRSuite(),
2428 makeISuite(),
2429 makePSuite(),
2430 makeESuite(),
2431 makeWSuite(),
2432 makeTOSuite(),
2433 makeEvtRenegeSuite(),
2434 makeLevelSuite(),
2435 makeStoreSuite(),
2436 makeStoreCompSuite(),
2437 makeLevelCompSuite(),
2438 makeMSuite()
2439 ))
2440
2441 runner = unittest.TextTestRunner()
2442 runner.run(alltests)
2443
2444