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