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