1
2 from SimPy.MonitorTest import *
3 from SimPy.SimulationTrace import *
4 import unittest
5 from random import random
6
7 """testSimPyTraceOO.py
8 SimPy version 2.0
9 Unit tests for SimulationTrace.
10
11 **Change history:**
12 # 2002 11 15 Added tests for priority queues and preemption
13 # 2002 11 22 testing problem in accum
14 # 2003 03 30 added tests for SEP001v17 interrupts
15 # 2003 04 05 added test for interruptReset
16 # 2003 04 08 added tests for process state transitions
17 # 2003 04 10 changed to 'self.cancel(victim)' syntax
18 # 2003 04 13 removed dummy init assertions
19 # 2004 02 28 added test for monitored queues (gav)
20 # 2004 05 03 corrected test for monitored queues (gav)
21 # 2004 05 03 first version of testSimPyTrace; does not
22 # explicitly test any SimulationTrace capabilities
23 # but uses it (see trace output)
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: 136 $ $Date: 2008-11-01 11:18:13 +0100 (Sa, 01 Nov 2008) $ kgm'
40
41 """
42 simulationTraceVersion=version
43 print "Under test: SimulationTrace.py %s"%simulationTraceVersion
44 __version__ = '2.0 $Revision: 136 $ $Date: 2008-11-01 11:18:13 +0100 (Sa, 01 Nov 2008) $ '
45 print 'testSimPyTraceOO.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=SimulationTrace()
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=SimulationTrace()
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=SimulationTrace()
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 s=SimulationTrace()
182 R0 = Resource(name='',capacity=0,sim=s)
183 assert R0.name == "", "Not null name"
184 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
185 s.initialize()
186 R1 = Resource(capacity=0,name="3-version",unitName="blobs")
187 J= Job(name="job",server=R1)
188 s.activate(J,J.execute(), at=0.0)
189
190 s.simulate(until=10.0)
191 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
192 lenW = len(R1.waitQ)
193 assert lenW==1,"Should be 1, it is "+str(lenW)
194 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
195 str(len(R1.activeQ))
196
198 """Test request2 with capacity = 1"""
199
200 s=SimulationTrace()
201 s.initialize()
202 R2 = Resource(capacity=1,name="3-version",unitName="blobs")
203 J2= Job(name="job",server=R2)
204 s.activate(J2,J2.execute(), at=0.0)
205
206 s.simulate(until = 10.0)
207 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
208 lenW = len(R2.waitQ)
209 lenA = len(R2.activeQ)
210 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
211 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
212
214 """Test request3 with capacity = 1 several requests"""
215
216 s=SimulationTrace()
217 s.initialize()
218 R3 = Resource(capacity=1,name="3-version",unitName="blobs")
219 J2= Job(name="job",server=R3)
220 J3= Job(name="job",server=R3)
221 J4= Job(name="job",server=R3)
222 s.activate(J2,J2.execute(), at=0.0)
223 s.activate(J3,J3.execute(), at=0.0)
224 s.activate(J4,J4.execute(), at=0.0)
225
226 s.simulate(until = 10.0)
227 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
228 lenW = len(R3.waitQ)
229 lenA = len(R3.activeQ)
230 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
231 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
232 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
233 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
234
236 """Test request4 with capacity = 2 several requests"""
237
238 s=SimulationTrace()
239 s.initialize()
240 R3 = Resource(capacity=2,name="4-version",unitName="blobs")
241 J2= Job(name="job",server=R3)
242 J3= Job(name="job",server=R3)
243 J4= Job(name="job",server=R3)
244 s.activate(J2,J2.execute(), at=0.0)
245 s.activate(J3,J3.execute(), at=0.0)
246 s.activate(J4,J4.execute(), at=0.0)
247
248 s.simulate(until = 10.0)
249 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
250 lenW = len(R3.waitQ)
251 lenA = len(R3.activeQ)
252 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
253 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
254 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
255 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
256
257
258
260 """Test PriorityQ, with no preemption, 0 capacity"""
261 class Job(Process):
262 """ Job class for testing"""
263 def __init__(self,server=None,name="",sim=None):
264 Process.__init__(self,name,sim)
265 self.name=name
266 self.R=server
267
268 def execute(self,priority):
269 yield request,self,self.R,priority
270
271 s=SimulationTrace()
272 s.initialize()
273 Rp = Resource(capacity=0,qType=PriorityQ,sim=s)
274 J5 = Job(name="job 5",server=Rp,sim=s)
275 J6 = Job(name="job 6",server=Rp,sim=s)
276 J7 = Job(name="job 7",server=Rp,sim=s)
277 s.activate(J5,J5.execute(priority=3))
278 s.activate(J6,J6.execute(priority=0))
279 s.activate(J7,J7.execute(priority=1))
280 s.simulate(until=100)
281 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
282 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
283
284 """Test PriorityQ mechanism"""
285
286 def sorted(q):
287 if not q or len(q) == 1:
288 sortok=1
289 return sortok
290 sortok = q[0] >= q[1] and sorted(q[2:])
291 return sortok
292
293 s=SimulationTrace()
294 s.initialize()
295 Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
296 for i in range(10):
297 J=Job(name="job "+str(i),server=Rp,sim=s)
298 s.activate(J,J.execute(priority=random()))
299 s.simulate(until=1000)
300 qp=[x._priority[Rp] for x in Rp.waitQ]
301 assert sorted(qp),"waitQ not sorted by priority: %s"\
302 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
303
305 """Test PriorityQ, with no preemption, capacity == 1"""
306 class Job(Process):
307 """ Job class for testing"""
308 def __init__(self,server=None,name="",sim=None):
309 Process.__init__(self,name,sim)
310 self.name=name
311 self.R=server
312
313 def execute(self,priority):
314 yield request,self,self.R,priority
315
316 s=SimulationTrace()
317 s.initialize()
318 Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
319 J5 = Job(name="job 5",server=Rp,sim=s)
320 J6 = Job(name="job 6",server=Rp,sim=s)
321 J7 = Job(name="job 7",server=Rp,sim=s)
322 s.activate(J5,J5.execute(priority=2))
323 s.activate(J6,J6.execute(priority=4))
324 s.activate(J7,J7.execute(priority=3))
325 s.simulate(until=100)
326 assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
327 %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
328
330 """Test PriorityQ, with preemption, capacity == 1"""
331 class nuJob(Process):
332 def __init__(self,name,sim=None):
333 Process.__init__(self,name,sim)
334
335 def execute(self,res,priority):
336 self.preempt=len(res.activeQ) > 0\
337 and priority > res.activeQ[-1]._priority[res]
338 t=self.sim.now()
339 yield request,self,res,priority
340 if self.preempt:
341 assert len(res.waitQ) == 1, \
342 "No preemption activeQ= %s"%res.activeQ[0].name
343 yield hold,self,30
344 t1=self.sim.now()
345 if self.preempt:
346 assert t+30 == t1,\
347 "Wrong completion time for preemptor %s"%self.name
348 else:
349 assert t+60 == t1,\
350 "Wrong completion time for preempted %s %s:"\
351 %(self.nameself.sim.now())
352 yield release,self,res
353
354 s = SimulationTrace()
355 s.initialize()
356 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
357 sim=s)
358 n1=nuJob(name="nuJob 1",sim=s)
359 n2=nuJob(name="nuJob 2",sim=s)
360 s.activate(n1,n1.execute(res,priority=0))
361 s.activate(n2,n2.execute(res,priority=1),at=15)
362 s.simulate(until=100)
363
365 """Test preemption of preemptor"""
366 class nuJob(Process):
367 seqOut=[]
368 def __init__(self,name,sim=None):
369 Process.__init__(self,name,sim)
370 self.serviceTime=30
371
372 def execute(self,res,priority):
373 self.preempt=len(res.activeQ) > 0\
374 and priority > res.activeQ[-1]._priority[res]
375 nrwaiting=len(res.waitQ)
376 yield request,self,res,priority
377 if self.preempt:
378 assert len(res.waitQ) == nrwaiting + 1,\
379 "No preemption activeQ= %s"%res.activeQ[0].name
380 yield hold,self,self.serviceTime
381 yield release,self,res
382 nuJob.seqOut.append((self,self.sim.now()))
383
384 s=SimulationTrace()
385 s.initialize()
386 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
387 sim=s)
388 n1=nuJob(name="nuJob 1",sim=s)
389 n2=nuJob(name="nuJob 2",sim=s)
390 n3=nuJob(name="nuJob 3",sim=s)
391 s.activate(n1,n1.execute(res,priority=-1))
392 start2=10
393 s.activate(n2,n2.execute(res,priority=0),at=start2)
394 start3=20
395 s.activate(n3,n3.execute(res,priority=1),at=start3)
396 s.simulate(until=100)
397 assert [x[1] for x in nuJob.seqOut]\
398 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
399 "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
400
402 """Test that a process can preempt another process holding multiple resources
403 """
404 class Requestor(Process):
405 def run(self,res1,res2,res3,priority=1):
406 yield request,self,res1,priority
407 yield request,self,res2,priority
408 yield request,self,res3,priority
409 record.observe(t=s.now(),y=self.name)
410 yield hold,self,100
411 record.observe(t=s.now(),y=self.name)
412 yield release,self,res3
413 yield release,self,res2
414 yield release,self,res1
415
416 s=SimulationTrace()
417 s.initialize()
418 outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
419 inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
420 innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
421 sim=s)
422 record=Monitor(sim=s)
423 r1=Requestor("r1",sim=s)
424 s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
425 r2=Requestor("r2",sim=s)
426 s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
427 at=50)
428 s.simulate(until=200)
429 assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
430 "was %s; preempt did not work"%record
431
433 """ test monitoring of number in the two queues, waitQ and activeQ
434 """
435 class Job(Process):
436 def __init__(self,name,sim=None):
437 Process.__init__(self,name,sim)
438
439 def execute(self,res):
440 yield request,self,res
441 yield hold,self,2
442 yield release,self,res
443
444 s=SimulationTrace()
445 s.initialize()
446 res=Resource(name="server",capacity=1,monitored=1,sim=s)
447 n1=Job(name="Job 1",sim=s)
448 n2=Job(name="Job 2",sim=s)
449 n3=Job(name="Job 3",sim=s)
450 s.activate(n1,n1.execute(res),at=2)
451 s.activate(n2,n2.execute(res),at=2)
452 s.activate(n3,n3.execute(res),at=2)
453 s.simulate(until=100)
454 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
455 'Wrong waitMon:%s'%res.waitMon
456 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
457 'Wrong actMon:%s'%res.actMon
458 self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/8.0,2,
459 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
460
462 suite = unittest.TestSuite()
463 testInit = makeResourcetestcase("testInit")
464 testrequest = makeResourcetestcase("testrequest")
465 testrequest2 = makeResourcetestcase("testrequest2")
466 testrequest3 = makeResourcetestcase("testrequest3")
467 testrequest4 = makeResourcetestcase("testrequest4")
468 testrequestPriority = makeResourcetestcase("testrequestPriority")
469 testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
470 testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
471 testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
472 testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
473 testmonitored = makeResourcetestcase("testmonitored")
474
475 suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
476 testrequestPriority,testrequestPriority1,
477 testrequestPriority2,testrequestPriority3,
478 testrequestNestedPreempt,
479 testmonitored])
480 return suite
481
482
483
484
485
489
490 - def breakin(self,waitbefore,howoften=1):
491 for i in range(howoften):
492 yield hold,self,waitbefore
493 self.interrupt(victim)
494
498
500 global igothit
501 igothit={}
502 while self.sim.now()<=theEnd:
503 yield hold,self,howlong
504 if self.interrupted():
505 byWhom=self.interruptCause
506 igothit[self.sim.now()]=byWhom
507 else:
508 pass
509
511 """
512 Tests interrupts as defined in SEP001v17
513 """
528
529
530
532 """
533 Test multiple interrupts during victim activity
534 """
535 global victim
536 s=SimulationTrace()
537 s.initialize()
538 breaker=Interruptor(sim=s)
539 s.activate(breaker,breaker.breakin(10,howoften=3))
540 victim=Interrupted(sim=s)
541 s.activate(victim,victim.myActivity(100))
542 s.simulate(until=200)
543 for i in (10,20,30):
544 assert igothit[i] == breaker, "Not interrupted at %s by breaker" %i
545 assert len(igothit) == 3 , "Interrupted wrong number of times"
546
560
562 """
563 Test multiple interrupts by multiple processes during victim activity
564 """
565 global victim
566 s=SimulationTrace()
567 s.initialize()
568 breaker1=Interruptor(sim=s)
569 s.activate(breaker1,breaker1.breakin(15,howoften=3))
570 breaker2=Interruptor(sim=s)
571 s.activate(breaker2,breaker2.breakin(20,howoften=3))
572 victim=Interrupted(sim=s)
573 s.activate(victim,victim.myActivity(100))
574 s.simulate(until=200)
575 for i in (15,30,45):
576 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
577 for i in (20,40,60):
578 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
579 assert len(igothit) == 6 , "Interrupted wrong number of times"
580
598
599 victim.newProcess=newProcess
600 s.activate(victim,newProcess(victim))
601 s.activate(breaker,breaker.breakin(10,howoften=3))
602 s.simulate(until=1000)
603
614
615
616
617
618
630
634
636 assert p.active(),"p not active"
637 assert not p.passive(), "p passive"
638 assert not p.terminated(),"p terminated"
639 assert not p.interrupted(),"p interrupted"
640 yield hold,self,11
641 assert not p.active(),"p active"
642 assert not p.passive(),"p passive"
643 assert p.terminated(),"p not terminated"
644 assert not p.interrupted(),"p interrupted"
645
647 assert not p.active(),"p active"
648 assert p.passive(),"p not passive"
649 assert not p.terminated(),"p not terminated"
650 assert not p.interrupted(),"p interrupted"
651 self.sim.activate(p,p.life1())
652 yield hold,self,11
653 assert not p.active(),"p active"
654 assert not p.passive(),"p not passive"
655 assert p.terminated(),"p not terminated"
656 assert not p.interrupted(),"p interrupted"
657
659 assert not p.active(),"p active"
660 assert p.passive(),"p not passive"
661 assert not p.terminated(),"p not terminated"
662 assert not p.interrupted(),"p interrupted"
663 self.sim.activate(p,p.life2())
664 yield hold,self,11
665 assert not p.active(),"p active"
666 assert p.passive(),"p not passive"
667 assert not p.terminated(),"p terminated"
668 assert not p.interrupted(),"p interrupted"
669
671 yield hold,self,5
672 assert p.active(),"p not active"
673 assert not p.passive(),"p passive"
674 assert not p.terminated(),"p terminated"
675 assert not p.interrupted(),"p interrupted"
676 self.cancel(p)
677 assert not p.active(),"p active"
678 assert p.passive(),"p not passive"
679 assert not p.terminated(),"p terminated"
680 assert not p.interrupted(),"p interrupted"
681 self.sim.reactivate(p)
682 assert p.active(),"p not active"
683 assert not p.passive(),"p passive"
684 assert not p.terminated(),"p terminated"
685 assert not p.interrupted(),"p interrupted"
686 yield hold,self
687 assert not p.active(),"p active"
688 assert not p.passive(),"p passive"
689 assert p.terminated(),"p terminated"
690 assert not p.interrupted(),"p interrupted"
691
693 yield hold,self,11
694 assert not p.active(),"p active"
695 assert p.passive(),"p not passive"
696 assert not p.terminated(),"p terminated"
697 assert not p.interrupted(),"p interrupted"
698 self.cancel(p)
699 assert not p.active(),"p active"
700 assert p.passive(),"p not passive"
701 assert not p.terminated(),"p terminated"
702 assert not p.interrupted(),"p interrupted"
703
721
725
726 - def look1(self,p1,p2,res):
727 assert p1.active(), "p1 not active"
728 assert not p1.queuing(res), "p1 queuing"
729 assert p2.active(), "p2 noit active"
730 assert not p2.queuing(res), "p2 queuing"
731 yield hold,self,2
732 assert p1.active(), "p1 not active"
733 assert not p1.queuing(res), "p1 queuing"
734 assert p2.passive(), "p2 active"
735 assert p2.queuing(res), "p2 not queuing"
736
745
747 """
748 Tests states and state transitions as defined in SEP003
749 """
750
763
782
804
806 """
807 Test request/release state transitions
808 """
809
810 s=SimulationTrace()
811 s.initialize()
812 res=Resource(capacity=1,sim=s)
813 pq1=PS2(sim=s)
814 s.activate(pq1,pq1.life1(res))
815 pq2=PS2(sim=s)
816 s.activate(pq2,pq2.life1(res))
817 obq1=Observer2(sim=s)
818 s.activate(obq1,obq1.look1(pq1,pq2,res))
819 s.simulate(until=12)
820
821
822 s=SimulationTrace()
823 s.initialize()
824 res=Resource(capacity=1,sim=s)
825 pq3=PS2(sim=s)
826 s.activate(pq3,pq3.life2(res))
827 obq2=Observer2(sim=s)
828 s.activate(obq2,obq2.look2(pq3,res),prior=True)
829 s.simulate(until=12)
830
840
841
842
843
844
849 yield hold,self,1
850 ev1.signal("from SignalProcess")
851 while ev2.queues:
852 nq0=len(ev2.queues)
853 ev2.signal("from SignalProcess")
854 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
855
860 yield waitevent,self,ev1
861 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
862 assert ev1 in self.eventsFired,"did not record firing event"
863
868 yield queueevent,self,ev2
869 assert ev2 in self.eventsFired,"did not record firing event"
870
873 yield hold,self,1
874 ev1.signal("from SignalProcess")
875 yield hold,self,3
876 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
877 while ev2.queues:
878 nq0=len(ev2.queues)
879 ev2.signal("from SignalProcess")
880 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
881 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
882
887 yield waitevent,self,evset
888 for e in evset:
889 assert e.waits==[],"process not out of waiting list for all events in OR"
890
901
902
904 nrProcesses=0
909 yield queueevent,self,evset
910 occurred=False
911 for e in evset:
912 occurred=occurred or (e in self.eventsFired)
913 assert occurred,"queuing process activated by wrong event(s)"
914
919 e1=SimEvent()
920 e1.signal()
921 e2=SimEvent()
922 e2.signal()
923 yield queueevent,self,[e1,e2]
924 assert self.eventsFired==[e1,e2],\
925 "(queueevent) eventsFired does not report all fired events"
926
928 """
929 Test SimEvent/signal as introduced with SimPy 1.5
930 """
931
933 """
934 Tests basic signal semantics
935 """
936 s=SimulationTrace()
937 s.initialize()
938 e=SimEvent(sim=s)
939 e.signal("param")
940 assert e.occurred,"signal does not set 'occurred' to True"
941 assert e.signalparam=="param","signal parameter wrong"
942 e.signal()
943 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
944 e.signal()
945 assert e.occurred,"multiple calls to signal do not set 'occurred'"
946
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
982 """
983 Tests waiting, queuing for at least one event out of a list/tuple.
984 """
985 si=SimulationTrace()
986 si.initialize()
987 e1=SimEvent("e1",sim=si)
988 e2=SimEvent("e2",sim=si)
989 e3=SimEvent("e3",sim=si)
990 s=SignalProcessOR(sim=si)
991 si.activate(s,s.makeSignal(e1,e3))
992 w=WaitProcessOR(sim=si)
993 si.activate(w,w.waitForSig([e1,e2]))
994 for i in range(5):
995 q=QueueProcessOR(sim=si)
996 si.activate(q,q.queueForSig([e2,e3]))
997 si.simulate(until=10)
998
1007
1016
1027
1028
1029
1030
1031
1036 global a,b,c
1037 a=True
1038 yield hold,self,1
1039 b=True
1040 yield hold,self,1
1041 c=True
1042 yield hold,self,1
1043 assert waiter.terminated(),"waituntil did not fire"
1044
1049 def waitcond():
1050 return a and b and c
1051 yield waituntil,self,waitcond
1052
1054 """
1055 Test waituntil as introduced with SimPy 1.5
1056 """
1057
1068
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1086 """ Job class for testing timeout reneging
1087 """
1088 - def __init__(self,server=None,name="",sim=None):
1092
1093 - def execute(self,timeout,usetime):
1094 yield (request,self,self.res),(hold,self,timeout)
1095 if self.acquired(self.res):
1096 self.gotResource=True
1097 yield hold,self,usetime
1098 yield release,self,self.res
1099 else:
1100 self.gotResource=False
1101
1103 """ Job class for testing timeout reneging with priorities
1104 """
1105 - def __init__(self,server=None,name="",sim=None):
1109
1110 - def execute(self,timeout,usetime,priority):
1111 yield (request,self,self.res,priority),(hold,self,timeout)
1112 if self.acquired(self.res):
1113 self.gotResource=True
1114 yield hold,self,usetime
1115 yield release,self,self.res
1116 else:
1117 self.gotResource=False
1118
1120 """ Tests of "yield (request,self,res),(hold,self,delay)"
1121 timeout reneging command
1122 """
1124 """Test that resource gets acquired without timeout
1125 """
1126
1127 s=SimulationTrace()
1128 s.initialize()
1129 res=Resource(name="Server",capacity=1,sim=s)
1130 usetime=5
1131 timeout=1000000
1132 j1=JobTO(server=res,name="Job_1",sim=s)
1133 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1134 j2=JobTO(server=res,name="Job_2",sim=s)
1135 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1136 s.simulate(until=2*usetime)
1137 assert s.now()==2*usetime,"time not ==2*usetime"
1138 assert j1.gotResource and j2.gotResource,\
1139 "at least one job failed to get resource"
1140 assert not (res.waitQ or res.activeQ),\
1141 "job waiting or using resource"
1142
1144 """Test that resource gets acquired without timeout.
1145 Resource monitored.
1146 """
1147
1148 s=SimulationTrace()
1149 s.initialize()
1150 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1151 usetime=5
1152 timeout=1000000
1153 j1=JobTO(server=res,name="Job_1",sim=s)
1154 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1155 j2=JobTO(server=res,name="Job_2",sim=s)
1156 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1157 s.simulate(until=2*usetime)
1158 assert s.now()==2*usetime,"time not ==2*usetime"
1159 assert j1.gotResource and j2.gotResource,\
1160 "at least one job failed to get resource"
1161 assert not (res.waitQ or res.activeQ),\
1162 "job waiting or using resource"
1163 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1164
1166 """Test that timeout occurs when resource busy
1167 """
1168
1169 s=SimulationTrace()
1170 s.initialize()
1171 res=Resource(name="Server",capacity=1,sim=s)
1172 usetime=5
1173 timeout=3
1174 j1=JobTO(server=res,name="Job_1",sim=s)
1175 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1176 j2=JobTO(server=res,name="Job_2",sim=s)
1177 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1178 s.simulate(until=2*usetime)
1179 assert(s.now()==usetime),"time not ==usetime"
1180 assert(j1.gotResource),"Job_1 did not get resource"
1181 assert(not j2.gotResource),"Job_2 did not renege"
1182 assert not (res.waitQ or res.activeQ),\
1183 "job waiting or using resource"
1184
1186 """Test that timeout occurs when resource busy.
1187 Resource monitored.
1188 """
1189 s=SimulationTrace()
1190 s.initialize()
1191 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1192 usetime=5
1193 timeout=3
1194 j1=JobTO(server=res,name="Job_1",sim=s)
1195 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1196 j2=JobTO(server=res,name="Job_2",sim=s)
1197 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1198 s.simulate(until=2*usetime)
1199 assert(s.now()==usetime),"time not == usetime"
1200 assert(j1.gotResource),"Job_1 did not get resource"
1201 assert(not j2.gotResource),"Job_2 did not renege"
1202 assert not (res.waitQ or res.activeQ),\
1203 "job waiting or using resource"
1204 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1205
1207 """Test that timeout occurs when resource busy.
1208 Resource monitored. Requests with priority and preemption.
1209 """
1210 s=SimulationTrace()
1211 s.initialize()
1212 res=Resource(name="Server",capacity=1,monitored=True,
1213 qType=PriorityQ,preemptable=True,sim=s)
1214 usetime=5
1215 timeout=3
1216 j1=JobTO_P(server=res,name="Job_1",sim=s)
1217 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1218 j2=JobTO_P(server=res,name="Job_2",sim=s)
1219 j2_arrival=1
1220 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
1221 at=j2_arrival)
1222 j3=JobTO_P(server=res,name="Job_2",sim=s)
1223 j3_arrival=2
1224 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
1225 at=j3_arrival)
1226 s.simulate(until=3*usetime)
1227 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1228 assert(j1.gotResource),"Job_1 did not get resource"
1229 assert(j2.gotResource),"Job_2 did renege"
1230 assert(j2.gotResource),"Job_3 did renege"
1231 assert not (res.waitQ or res.activeQ),\
1232 "job waiting or using resource"
1233 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1234 "res.waitMon wrong: %s"%res.waitMon
1235
1237 """Test that timeout occurs when resource has no capacity free
1238 """
1239
1240 s=SimulationTrace()
1241 s.initialize()
1242 res=Resource(name="Server",capacity=0,sim=s)
1243 usetime=5
1244 timeout=3
1245 j1=JobTO(server=res,name="Job_1",sim=s)
1246 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1247 j2=JobTO(server=res,name="Job_2",sim=s)
1248 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1249 s.simulate(until=2*usetime)
1250 assert s.now()==timeout,"time %s not == timeout"%now()
1251 assert not j1.gotResource,"Job_1 got resource"
1252 assert not j2.gotResource,"Job_2 got resource"
1253 assert not (res.waitQ or res.activeQ),\
1254 "job waiting or using resource"
1255
1257 """Test that timeout occurs when resource has no capacity free.
1258 Resource monitored.
1259 """
1260
1261 s=SimulationTrace()
1262 s.initialize()
1263 res=Resource(name="Server",capacity=0,monitored=True,sim=s)
1264 usetime=5
1265 timeout=3
1266 j1=JobTO(server=res,name="Job_1",sim=s)
1267 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1268 j2=JobTO(server=res,name="Job_2",sim=s)
1269 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1270 s.simulate(until=2*usetime)
1271 assert s.now()==timeout,"time %s not == timeout"%now()
1272 assert not j1.gotResource,"Job_1 got resource"
1273 assert not j2.gotResource,"Job_2 got resource"
1274 assert not (res.waitQ or res.activeQ),\
1275 "job waiting or using resource"
1276 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1277 "res.waitMon is wrong: %s"%res.waitMon
1278
1292
1293
1294
1295
1296
1297
1298
1299
1301 """ Job class for testing event reneging
1302 """
1303 - def __init__(self,server=None,name="",sim=None):
1307
1309 yield (request,self,self.res),(waitevent,self,event)
1310 if self.acquired(self.res):
1311 self.gotResource=True
1312 yield hold,self,usetime
1313 yield release,self,self.res
1314 else:
1315 self.gotResource=False
1316
1318 """ Job class for testing event reneging with multi-event lists
1319 """
1320 - def __init__(self,server=None,name="",sim=None):
1324
1325 - def execute(self,eventlist,usetime):
1326 yield (request,self,self.res),(waitevent,self,eventlist)
1327 if self.acquired(self.res):
1328 self.gotResource=True
1329 yield hold,self,usetime
1330 yield release,self,self.res
1331 else:
1332 self.gotResource=False
1333
1335 """Fires reneging event
1336 """
1339 - def fire(self,fireDelay,event):
1340 yield hold,self,fireDelay
1341 event.signal()
1342
1344 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1345 event reneging command
1346 """
1348 """Test that processes acquire resource normally if no event fires
1349 """
1350 s=SimulationTrace()
1351 s.initialize()
1352 event=SimEvent("Renege_trigger",sim=s)
1353 res=Resource(name="Server",capacity=1,sim=s)
1354 usetime=5
1355 j1=JobEvt(server=res,name="Job_1",sim=s)
1356 s.activate(j1,j1.execute(event=event,usetime=usetime))
1357 j2=JobEvt(server=res,name="Job_2",sim=s)
1358 s.activate(j2,j2.execute(event=event,usetime=usetime))
1359 s.simulate(until=2*usetime)
1360
1361 assert s.now()==2*usetime,"time not ==2*usetime"
1362 assert j1.gotResource and j2.gotResource,\
1363 "at least one job failed to get resource"
1364 assert not (res.waitQ or res.activeQ),\
1365 "job waiting or using resource"
1366
1368 """Test that processes acquire resource normally if no event fires.
1369 Resource monitored.
1370 """
1371 s=SimulationTrace()
1372 s.initialize()
1373 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1374 event=SimEvent("Renege_trigger",sim=s)
1375 usetime=5
1376 j1=JobEvt(server=res,name="Job_1",sim=s)
1377 s.activate(j1,j1.execute(event=event,usetime=usetime))
1378 j2=JobEvt(server=res,name="Job_2",sim=s)
1379 s.activate(j2,j2.execute(event=event,usetime=usetime))
1380 s.simulate(until=2*usetime)
1381
1382 assert s.now()==2*usetime,"time not ==2*usetime"
1383 assert j1.gotResource and j2.gotResource,\
1384 "at least one job failed to get resource"
1385 assert not (res.waitQ or res.activeQ),\
1386 "job waiting or using resource"
1387 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1388
1390 """Test that signalled event leads to renege when resource busy
1391 """
1392
1393 s=SimulationTrace()
1394 s.initialize()
1395 res=Resource(name="Server",capacity=1,sim=s)
1396 event=SimEvent("Renege_trigger",sim=s)
1397 usetime=5
1398 eventtime=1
1399 j1=JobEvt(server=res,name="Job_1",sim=s)
1400 s.activate(j1,j1.execute(event=event,usetime=usetime))
1401 j2=JobEvt(server=res,name="Job_2",sim=s)
1402 s.activate(j2,j2.execute(event=event,usetime=usetime))
1403 f=FireEvent(name="FireEvent",sim=s)
1404 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1405 s.simulate(until=2*usetime)
1406
1407 assert(s.now()==usetime),"time not ==usetime"
1408 assert(j1.gotResource),"Job_1 did not get resource"
1409 assert(not j2.gotResource),"Job_2 did not renege"
1410 assert not (res.waitQ or res.activeQ),\
1411 "job waiting or using resource"
1412
1414 """Test that signalled event leads to renege when resource busy.
1415 Resource monitored.
1416 """
1417
1418 s=SimulationTrace()
1419 s.initialize()
1420 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1421 event=SimEvent("Renege_trigger",sim=s)
1422 usetime=5
1423 eventtime=1
1424 j1=JobEvt(server=res,name="Job_1",sim=s)
1425 s.activate(j1,j1.execute(event=event,usetime=usetime))
1426 j2=JobEvt(server=res,name="Job_2",sim=s)
1427 s.activate(j2,j2.execute(event=event,usetime=usetime))
1428 f=FireEvent(name="FireEvent",sim=s)
1429 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1430 s.simulate(until=2*usetime)
1431
1432 assert(s.now()==usetime),"time not ==usetime"
1433 assert(j1.gotResource),"Job_1 did not get resource"
1434 assert(not j2.gotResource),"Job_2 did not renege"
1435 assert not (res.waitQ or res.activeQ),\
1436 "job waiting or using resource"
1437 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1438
1440 """Test that renege-triggering event can be one of an event list
1441 """
1442
1443 s=SimulationTrace()
1444 s.initialize()
1445 res=Resource(name="Server",capacity=1,sim=s)
1446 event1=SimEvent("Renege_trigger_1",sim=s)
1447 event2=SimEvent("Renege_trigger_2",sim=s)
1448 usetime=5
1449 eventtime=1
1450 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1451 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1452 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1453 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1454 f1=FireEvent(name="FireEvent_1",sim=s)
1455 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1456 f2=FireEvent(name="FireEvent_2",sim=s)
1457 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1458 s.simulate(until=2*usetime)
1459
1460 assert(s.now()==usetime),"time not ==usetime"
1461 assert(j1.gotResource),"Job_1 did not get resource"
1462 assert(not j2.gotResource),"Job_2 did not renege"
1463 assert not (res.waitQ or res.activeQ),\
1464 "job waiting or using resource"
1465
1467 """Test that renege-triggering event can be one of an event list.
1468 Resource monitored.
1469 """
1470
1471 s=SimulationTrace()
1472 s.initialize()
1473 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1474 event1=SimEvent("Renege_trigger_1",sim=s)
1475 event2=SimEvent("Renege_trigger_2",sim=s)
1476 usetime=5
1477 eventtime=1
1478 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1479 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1480 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1481 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1482 f1=FireEvent(name="FireEvent_1",sim=s)
1483 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1484 f2=FireEvent(name="FireEvent_2",sim=s)
1485 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1486 s.simulate(until=2*usetime)
1487
1488 assert(s.now()==usetime),"time not ==usetime"
1489 assert(j1.gotResource),"Job_1 did not get resource"
1490 assert(not j2.gotResource),"Job_2 did not renege"
1491 assert not (res.waitQ or res.activeQ),\
1492 "job waiting or using resource"
1493 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1494
1507
1508
1509
1510
1511
1512
1514 produced=0
1523 """PriorityQ for Producers"""
1524 Producer.produced+=4
1525 yield put,self,buffer,4,priority
1526 yield hold,self,1
1527 self.done=self.sim.now()
1528 doneList.append(self.name)
1530 for i in range(4):
1531 yield put,self,buffer,4
1532 yield hold,self,1
1534 consumed=0
1538 """FIFO"""
1539 yield get,self,buffer
1540 Consumer.consumed+=1
1541 assert self.got==1,"wrong self.got: %s"%self.got
1542 yield get,self,buffer,3
1543 Consumer.consumed+=3
1544 assert self.got==3,"wrong self.got: %s"%self.got
1545
1547 """producer PriorityQ, consumer FIFO"""
1548 while True:
1549 yield get,self,buffer,2
1550 yield hold,self,1
1552 """PriorityQ for Consumers"""
1553 yield get,self,buffer,4,priority
1554 doneList.append(self.name)
1555
1556
1560 - def produce(self,buffer,productionTime):
1561 while True:
1562 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1563 "Consumer(s) waiting while buffer not empty"
1564 yield hold,self,productionTime
1565 yield put,self,buffer,1
1566
1570 - def consume(self,buffer,consumptionTime):
1571 while True:
1572 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1573 "Producer(s) waiting while buffer empty"
1574 yield get,self,buffer,1
1575 yield hold,self,consumptionTime
1576
1577
1578
1581 """Tests initialization of Level instances
1582 """
1583 s=SimulationTrace()
1584 s.initialize()
1585 a=Level(sim=s)
1586 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1587 assert a.amount==0,"wrong buffer content: %s"%a
1588 assert a.name=="a_level","wrong name: %s"%a
1589 assert not a.monitored,"should not be monitored: %s"%a
1590 assert a.putQMon is None,"should not have putQMon: %s"%a
1591 assert a.getQMon is None,"should not have getQMon: %s"%a
1592 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1593 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1594 "putQType and getQType should be FIFO: %s"%a
1595
1596 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1597 putQType=PriorityQ,sim=s)
1598 a=Level(sim=s)
1599 assert b.capacity==12,"wrong capacity:%s"%b
1600 assert b.amount==10,"wrong buffer content: %s"%b
1601 assert b.name=="b","wrong name: %s"%b
1602 assert b.monitored,"should be monitored: %s"%b
1603 assert not (b.putQMon is None),"should have putQMon: %s"%b
1604 assert not (b.getQMon is None),"should have getQMon: %s"%b
1605 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1606 assert b.putQType.__name__=="PriorityQ",\
1607 "putQType should be PriorityQ: %s"%b
1608 assert b.getQType.__name__=="FIFO",\
1609 "getQType should be PriorityQ: %s"%b
1610
1612 """Level: tests basic Producer/Consumer principles:
1613 - Consumers must not be waiting while Level buffer value > 0,
1614 - Producers must not be waiting while Level buffer value == 0
1615 """
1616 s=SimulationTrace()
1617 s.initialize()
1618 bufferSize=1
1619 productionTime=1
1620 consumptionTime=5
1621 endtime=50
1622 buffer=Level(capacity=bufferSize,sim=s)
1623 consumer=ConsumerPrincL(sim=s)
1624 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1625 producer=ProducerPrincL(sim=s)
1626 s.activate(producer,producer.produce(buffer,productionTime))
1627 s.simulate(until=endtime)
1628
1642
1660
1662 """Level: tests put/get in multiple Producer/Consumer scenario,
1663 with Producers having different priorities.
1664 How: Producers forced to queue; all after first should be done in
1665 priority order
1666 """
1667 global doneList
1668 doneList=[]
1669 s=SimulationTrace()
1670 s.initialize()
1671 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1672 for i in range(4):
1673 p=Producer(i,sim=s)
1674 pPriority=i
1675 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1676 c=Consumer(sim=s)
1677 s.activate(c,c.consume1(buffer=buffer))
1678 s.simulate(until=100)
1679 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1680 %doneList
1681
1683 """Level: tests put/get in multiple Producer/Consumer scenario, with
1684 Consumers having different priorities.
1685 How: Consumers forced to queue; all after first should be done in
1686 priority order
1687 """
1688 global doneList
1689 doneList=[]
1690 s=SimulationTrace()
1691 s.initialize()
1692 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1693 for i in range(4):
1694 c=Consumer(i,sim=s)
1695 cPriority=i
1696 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1697 p=Producer(sim=s)
1698 s.activate(p,p.produce1(buffer=buffer))
1699 s.simulate(until=100)
1700 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\
1701 %doneList
1702
1714
1715
1716
1717
1718
1719
1720
1745
1773
1777
1779 """Sorts Widget instances by weight attribute."""
1780 tmplist=[(x.weight,x) for x in par]
1781 tmplist.sort()
1782 return [x for (key,x) in tmplist]
1783
1784
1788 - def produce(self,buffer,productionTime):
1789 while True:
1790 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1791 "Consumer(s) waiting while buffer not empty"
1792 yield hold,self,productionTime
1793 product=WidgetPrinc()
1794 yield put,self,buffer,[product]
1795
1799 - def consume(self,buffer,consumptionTime):
1800 while True:
1801 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1802 "Producer(s) waiting while buffer empty"
1803 yield get,self,buffer,1
1804 yield hold,self,consumptionTime
1805
1808
1810 """Used in testBufferFilter"""
1816
1818 """get all items with weight between a and b"""
1819 def between_a_and_b(buf):
1820 res=[]
1821 for item in buf:
1822 if a<item.weight<b:
1823 res.append(item)
1824
1825 all=store.buffered
1826 yield get,self,store,between_a_and_b
1827 "All retrieved items weight in range?"
1828 for it in self.got:
1829 assert a<it.weight<b,"weight %s not in range %s..%s"\
1830 %(it.weight,a,b)
1831 "Any item fitting filter pred left in buffer?"
1832 for it in store.buffer:
1833 assert not (a<it.weight<b),\
1834 "item left in buffer which fits filter (%s<%s<%s)"\
1835 %(a,it.weight,b)
1836 "All items either in store.buffer of self.got?"
1837 for it in all:
1838 assert (it in self.buffer) or (it in self.got),\
1839 "item w. weight %s neither in store nor in got"%it.weight
1840
1841
1842
1845 """Store: tests initialization of Store instances
1846 """
1847 s=SimulationTrace()
1848 s.initialize()
1849 a=Store(sim=s)
1850 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1851 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1852 assert a.name=="a_store","wrong name: %s"%a
1853 assert not a.monitored,"should not be monitored: %s"%a
1854 assert a.putQMon is None,"should not have putQMon: %s"%a
1855 assert a.getQMon is None,"should not have getQMon: %s"%a
1856 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1857 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1858 "putQType and getQType should be FIFO: %s"%a
1859
1860 stored=[Widget(weight=5)]*10
1861 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1862 putQType=PriorityQ,sim=s)
1863 assert b.capacity==12,"wrong capacity:%s"%b
1864 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1865 assert b.name=="b","wrong name: %s"%b
1866 assert b.monitored,"should be monitored: %s"%b
1867 assert not (b.putQMon is None),"should have putQMon: %s"%b
1868 assert not (b.getQMon is None),"should have getQMon: %s"%b
1869 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1870 assert b.putQType.__name__=="PriorityQ",\
1871 "putQType should be PriorityQ: %s"%b
1872 assert b.getQType.__name__=="FIFO",\
1873 "getQType should be PriorityQ: %s"%b
1874
1876 """Store: tests basic Producer/Consumer principles:
1877 - Consumers must not be waiting while items in Store buffer,
1878 - Producers must not be waiting while space available in Store buffer
1879 """
1880 bufferSize=1
1881 productionTime=1
1882 consumptionTime=5
1883 endtime=50
1884 s=SimulationTrace()
1885 s.initialize()
1886 buffer=Store(capacity=bufferSize,sim=s)
1887 consumer=ConsumerPrincS(sim=s)
1888 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1889 producer=ProducerPrincS(sim=s)
1890 s.activate(producer,producer.produce(buffer,productionTime))
1891 s.simulate(until=endtime)
1892
1907
1925
1927 """Store: Tests put/get in multiple Producer/Consumer scenario,
1928 with Producers having different priorities.
1929 How; Producers forced to queue; all after first should be done in
1930 priority order
1931 """
1932 global doneList
1933 doneList=[]
1934 s=SimulationTrace()
1935 s.initialize()
1936 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1937 for i in range(4):
1938 p=ProducerWidget(name=i,sim=s)
1939 pPriority=i
1940 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1941 c=ConsumerWidget(sim=s)
1942 s.activate(c,c.consume1(buffer=buffer))
1943 s.simulate(until=100)
1944 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1945 %doneList
1946
1948 """Tests put/get in multiple Producer/Consumer scenario, with
1949 Consumers having different priorities.
1950 How; Consumers forced to queue; all after first should be done in
1951 priority order
1952 """
1953 global doneList
1954 doneList=[]
1955 s=SimulationTrace()
1956 s.initialize()
1957 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1958 for i in range(4):
1959 c=ConsumerWidget(name=str(i),sim=s)
1960 cPriority=i
1961 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1962 p=ProducerWidget(sim=s)
1963 s.activate(p,p.produce1(buffer=buffer))
1964 s.simulate(until=100)
1965 assert doneList==["3","2","1","0"],\
1966 "gets were not done in priority order: %s"%doneList
1967
1969 """Tests the optional sorting of theBuffer by applying a user-defined
1970 sort function."""
1971 s=SimulationTrace()
1972 s.initialize()
1973 gotten=[]
1974 sortedStore=Store(sim=s)
1975 sortedStore.addSort(mySortFunc)
1976 p=ProducerWidget(sim=s)
1977 s.activate(p,p.produceUnordered(sortedStore))
1978 for i in range(9):
1979 c=ConsumerWidget(sim=s)
1980 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
1981 s.simulate(until=10)
1982 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1983
1996
2011
2012
2013
2014
2015
2016
2017 -class TBT(Process):
2018 """Store: For testBasicTime"""
2021 - def tbt(self,store):
2022 yield get,self,store,1
2023 assert self.got,"Did not get Item"
2024 yield (get,self,store,1),(hold,self,5)
2025 if self.acquired(store):
2026 assert len(self.got)==1,"did not get 1 Item"
2027 else:
2028 assert not self.got and self.sim.now()==5 and not store.getQ,\
2029 "time renege not working"
2030
2031 -class TBE(Process):
2032 """Store: For testBasicEvent"""
2035 - def tbe(self,store,trigger):
2036 yield get,self,store,1
2037 assert self.got,"Did not get Item"
2038 yield (get,self,store,1),(waitevent,self,trigger)
2039 if self.acquired(store):
2040 assert False, "should have reneged"
2041 else:
2042 assert self.eventsFired[0]==trigger and self.sim.now()==5 \
2043 and not store.getQ,"event renege not working"
2044
2046 """Store: For testBasicEvent"""
2049 - def fire(self,trigger):
2052
2053
2055 """Store: for testBasicTimePut"""
2058 - def tbt(self,store):
2059 class Item:pass
2060 yield (put,self,store,[Item()]),(hold,self,4)
2061 if self.stored(store):
2062 assert store.nrBuffered==1 and not store.putQ,\
2063 "put did not execute"
2064 else:
2065 assert False,"should not have reneged"
2066 yield (put,self,store,[Item()]),(hold,self,5)
2067 if self.stored(store):
2068 assert False,"should have reneged"
2069 else:
2070 assert store.nrBuffered==1 and not store.putQ,\
2071 "renege not working correctly"
2072
2074 """Store: for testBasicEventPut"""
2077 - def tbe(self,store,trigger):
2078 class Item:pass
2079 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2080 if self.stored(store):
2081 assert store.nrBuffered==1 and not store.putQ,\
2082 "put did not execute"
2083 else:
2084 assert False,"should have not have reneged"
2085 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2086 if self.stored(store):
2087 assert False,"should have reneged"
2088 else:
2089 assert self.sim.now()==5 and self.eventsFired[0]==trigger\
2090 and not store.putQ,"renege not working correctly"
2091
2093 """Store: For testBasicEventPut"""
2096 - def fire(self,trigger):
2099
2101 """Store: Testcase for compound get statements"""
2102
2103
2104
2105
2106
2107
2118
2119
2120
2121
2122
2123
2133
2135 """Store (monitored):
2136 test monitors with 'yield (put,self,store),(hold,self,time)"""
2137 s=SimulationTrace()
2138 s.initialize()
2139 st=Store(capacity=1,monitored=True,sim=s)
2140 t=TBTput(sim=s)
2141 s.activate(t,t.tbt(store=st))
2142 s.simulate(until=10)
2143
2144 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2145 %st.putQMon
2146
2147 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2148
2149
2150
2151
2152
2153
2167
2168
2169
2170
2171
2172
2185
2187 """Store (monitored):
2188 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2189 si=SimulationTrace()
2190 si.initialize()
2191 s=SimEvent(sim=si)
2192 st=Store(capacity=1,monitored=True,sim=si)
2193 t=TBEtriggerPut(sim=si)
2194 si.activate(t,t.fire(trigger=s))
2195 tb=TBEput(sim=si)
2196 si.activate(tb,tb.tbe(store=st,trigger=s))
2197 si.simulate(until=10)
2198
2199 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2200 %st.putQMon
2201
2202 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2203
2219
2220
2221
2222
2223
2224
2226 """Level: For testBasicTime"""
2229 - def tbt(self,level):
2230 yield get,self,level,1
2231 assert self.got,"did not get 1 unit"
2232 yield (get,self,level,1),(hold,self,5)
2233 if self.acquired(level):
2234 assert self.got==1,"did not get 1 unit"
2235 else:
2236 assert not self.got and self.sim.now()==5,\
2237 "time renege not working"
2238
2240 """Level: For testBasicEvent"""
2243 - def tbe(self,level,trigger):
2244 yield get,self,level,1
2245 assert self.got,"did not get 1 unit"
2246 yield (get,self,level,1),(waitevent,self,trigger)
2247 if self.acquired(level):
2248 assert self.got==1,"did not get 1 Item"
2249 else:
2250 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
2251 "event renege not working"
2252
2254 """Level: For testBasicEvent"""
2257 - def fire(self,trigger):
2260
2262 """Level: For testBasicTimePut"""
2265 - def tbt(self,level):
2266 yield put,self,level,1
2267 assert level.amount,"did not put 1 unit"
2268 yield (put,self,level,1),(hold,self,5)
2269 if self.stored(level):
2270 assert False,"should have reneged"
2271 else:
2272 assert level.amount==1 and self.sim.now()==5,\
2273 "time renege not working"
2274
2276 """Level: For testBasicEventPut and testBasicEventPutM"""
2279 - def tbe(self,level,trigger):
2280 yield (put,self,level,1),(waitevent,self,trigger)
2281 if self.stored(level):
2282 assert level.amount==1,"did not put 1 unit"
2283 else:
2284 assert False,"should not have reneged"
2285 yield (put,self,level,1),(waitevent,self,trigger)
2286 if self.stored(level):
2287 assert False, "should have reneged"
2288 else:
2289 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
2290 "renege not working"
2291
2293 """Level: For testBasicEventPut"""
2296 - def fire(self,trigger):
2299
2301 """Level: Testcase for compound get and put statements"""
2302
2303
2304
2305
2306
2307
2318
2319
2320
2321
2322
2323
2333
2334
2335
2336
2337
2338
2351
2353 """Level (monitored):
2354 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2355 s=SimulationTrace()
2356 s.initialize()
2357 l=Level(initialBuffered=1,monitored=True,sim=s)
2358 trig=SimEvent(sim=s)
2359 t=TBELev(sim=s)
2360 s.activate(t,t.tbe(level=l,trigger=trig))
2361 tr=TBEtriggerLev(sim=s)
2362 s.activate(tr,tr.fire(trigger=trig))
2363 s.simulate(until=10)
2364
2365 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2366 %l.getQMon
2367
2368 assert l.bufferMon==[[0,1],[0,0]],\
2369 "bufferMon not working: %s"%l.bufferMon
2370
2371
2372
2373
2374
2375
2388
2390 """Level (monitored):
2391 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2392 s=SimulationTrace()
2393 s.initialize()
2394 l=Level(capacity=1,monitored=True,sim=s)
2395 trig=SimEvent(sim=s)
2396 t=TBELevPut(sim=s)
2397 s.activate(t,t.tbe(level=l,trigger=trig))
2398 tr=TBEtriggerLevPut(sim=s)
2399 s.activate(tr,tr.fire(trigger=trig))
2400 s.simulate(until=10)
2401 "First put succeeds, second reneges at t=5.5?"
2402 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2403 %l.putQMon
2404 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2405 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2406
2421
2422 if __name__ == '__main__':
2423 alltests = unittest.TestSuite((
2424 makeSSuite(),
2425 makeRSuite(),
2426 makeISuite(),
2427 makePSuite(),
2428 makeESuite(),
2429 makeWSuite(),
2430 makeTOSuite(),
2431 makeEvtRenegeSuite(),
2432 makeLevelSuite(),
2433 makeStoreSuite(),
2434 makeStoreCompSuite(),
2435 makeLevelCompSuite(),
2436 makeMSuite()
2437 ))
2438
2439 runner = unittest.TextTestRunner()
2440 runner.run(alltests)
2441
2442