1
2
3 from SimPy.MonitorTest import *
4 from SimPy.SimulationStep import *
5 import sys
6 import unittest
7 from random import random
8
9
10 """testSimPyStep.py
11 SimPy version 2.1
12 Unit tests for SimulationStep (OO mode).
13
14
15 """
16 simulationStepVersion=version
17 print "Under test: SimulationStep.py %s"%simulationStepVersion
18 __version__ = '2.1 $Revision: 438 $ $Date: 2010-04-02 05:48:49 +0200 (Fri, 02 Apr 2010) $ '
19 print 'testSimPyStepOO.py %s'%__version__
20
21
22
23
25 """ P class for testing"""
26 - def __init__(self,name="",T = 0,sim=None):
30
32 yield hold,self,self.T
33
35 """ PActions class for testing"""
36 - def __init__(self,name="",T = 0,sim=None):
40
42 yield hold,self,self.T
43
45 """For testing stopSimulation
46 """
47 - def run(self,stopTime):
51
53 """For testing startCollection
54 """
55 - def run(self,mon1,mon2,tal1,tal2):
62
64 """For testing allEventTimes
65 """
68
69
71 """ Tests of simulation
72 """
74 """Test initialisation
75 """
76 s=SimulationStep()
77 s.initialize()
78 result=s.simulate(until=10)
79 assert result=="SimPy: No activities scheduled",\
80 "There should have been no activities."
81 assert(s.now()==0),"time not 0"
82
92
102
112
114 """Test yield hold and simulate(until)
115 """
116 s=SimulationStep()
117 s.initialize()
118 P1 = P(name="P1",T=10,sim=s)
119 s.initialize()
120 s.activate(P1,P1.execute(),0)
121 s.simulate(until=5)
122 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
123
124 P2 = P(name="P2",T=10,sim=s)
125 s.initialize()
126 s.activate(P2,P2.execute(),0)
127 s.simulate(until=20)
128 assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
129
130
131
132
133
135 """Test stopSimulation function/method
136 """
137 timeToStop = 7
138 s = SimulationStep()
139 ts = ToStop(sim = s)
140 s.activate(ts,ts.run(stopTime = timeToStop))
141 s.simulate(until = 50)
142 assert(s.now()==timeToStop),\
143 "stopSimulation not working; now = %s instead of %s"%(now(),timeToStop)
144
146 """Test startCollection function/method
147 """
148 s = SimulationStep()
149 tStart = 9
150 mon1 = Monitor("mon1",sim = s)
151 mon2 = Monitor("mon2",sim = s)
152 tal1 = Tally("tal1",sim = s)
153 tal2 = Tally("tal2",sim = s)
154 s.startCollection(when = tStart,monitors=[mon1,mon2],tallies=[tal1,tal2])
155 tc = ToCollect(sim = s)
156 s.activate(tc,tc.run(mon1,mon2,tal1,tal2))
157 s.simulate(until=50)
158 assert(mon1[0]==mon2[0]==[tStart,tStart]),\
159 "startCollection not working correctly for Monitors"
160 assert(tal1.count()==tal2.count()==50-tStart+1),\
161 "startCollection not working for Tally"
162
172
173
188
189
190
191
192
194 """ Job class for testing"""
195 - def __init__(self,server=None,name="",sim=None):
199
202
204 """ First simple tests of Resources
205 """
207 """Test initialisation"""
208 s=SimulationStep()
209 s.initialize()
210 R = Resource(sim=s)
211 assert R.name == "a_resource", "Not null name"
212 assert R.capacity == 1, "Not unit capacity"
213 assert R.unitName =="units", "Not the correct unit name"
214 R = Resource(name='',capacity=1,sim=s)
215 assert R.name == "", "Not null name"
216 assert R.capacity == 1, "Not unit capacity"
217 assert R.unitName =="units", "Not the correct unit name"
218 R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s)
219 assert R.name =="3-version" , "Wrong name, it is"+R.name
220 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
221 assert R.unitName =="blobs", "Not the correct unit name"
222
223 R = Resource(capacity=0,name="0-version",sim=s)
224 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
225
227 """Test request"""
228
229 s=Simulation()
230 s.initialize()
231 R0 = Resource(name='',capacity=0, sim = s)
232 assert R0.name == "", "Not null name"
233 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
234 R1 = Resource(capacity=0,name="3-version",unitName="blobs", sim = s)
235 J= Job(name="job",server=R1, sim = s)
236 s.activate(J,J.execute(), at=0.0)
237
238 s.simulate(until=10.0)
239 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
240 lenW = len(R1.waitQ)
241 assert lenW==1,"Should be 1, it is "+str(lenW)
242 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
243 str(len(R1.activeQ))
244
246 """Test request2 with capacity = 1"""
247
248 s=SimulationStep()
249 s.initialize()
250 R2 = Resource(capacity=1,name="3-version",unitName="blobs", sim = s)
251 J2= Job(name="job",server=R2, sim = s)
252 s.activate(J2,J2.execute(), at=0.0)
253
254 s.simulate(until = 10.0)
255 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
256 lenW = len(R2.waitQ)
257 lenA = len(R2.activeQ)
258 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
259 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
260
262 """Test request3 with capacity = 1 several requests"""
263
264 s=SimulationStep()
265 s.initialize()
266 R3 = Resource(capacity=1,name="3-version",unitName="blobs", sim = s)
267 J2= Job(name="job",server=R3, sim = s)
268 J3= Job(name="job",server=R3, sim = s)
269 J4= Job(name="job",server=R3, sim = s)
270 s.activate(J2,J2.execute(), at=0.0)
271 s.activate(J3,J3.execute(), at=0.0)
272 s.activate(J4,J4.execute(), at=0.0)
273
274 s.simulate(until = 10.0)
275 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
276 lenW = len(R3.waitQ)
277 lenA = len(R3.activeQ)
278 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
279 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
280 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
281 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
282
284 """Test request4 with capacity = 2 several requests"""
285
286 s=SimulationStep()
287 s.initialize()
288 R3 = Resource(capacity=2,name="4-version",unitName="blobs", sim = s)
289 J2= Job(name="job",server=R3, sim = s)
290 J3= Job(name="job",server=R3, sim = s)
291 J4= Job(name="job",server=R3, sim = s)
292 s.activate(J2,J2.execute(), at=0.0)
293 s.activate(J3,J3.execute(), at=0.0)
294 s.activate(J4,J4.execute(), at=0.0)
295
296 s.simulate(until = 10.0)
297 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
298 lenW = len(R3.waitQ)
299 lenA = len(R3.activeQ)
300 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
301 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
302 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
303 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
304
305
306
308 """Test PriorityQ, with no preemption, 0 capacity"""
309 class Job(Process):
310 """ Job class for testing"""
311 def __init__(self,server=None,name="",sim=None):
312 Process.__init__(self,name = name,sim = sim)
313
314 self.R=server
315
316 def execute(self,priority):
317 yield request,self,self.R,priority
318
319 s=SimulationStep()
320 s.initialize()
321 Rp = Resource(capacity=0,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=3))
326 s.activate(J6,J6.execute(priority=0))
327 s.activate(J7,J7.execute(priority=1))
328 s.simulate(until=100)
329 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
330 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
331
332 """Test PriorityQ mechanism"""
333
334 def sorted(q):
335 if not q or len(q) == 1:
336 sortok=1
337 return sortok
338 sortok = q[0] >= q[1] and sorted(q[2:])
339 return sortok
340
341 s=SimulationStep()
342 s.initialize()
343 Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
344 for i in range(10):
345 J=Job(name="job "+str(i),server=Rp,sim=s)
346 s.activate(J,J.execute(priority=random()))
347 s.simulate(until=1000)
348 qp=[x._priority[Rp] for x in Rp.waitQ]
349 assert sorted(qp),"waitQ not sorted by priority: %s"\
350 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
351
353 """Test PriorityQ, with no preemption, capacity == 1"""
354 class Job(Process):
355 """ Job class for testing"""
356 def __init__(self,server=None,name="",sim=None):
357 Process.__init__(self, name = name, sim = sim)
358
359 self.R=server
360
361 def execute(self,priority):
362 yield request,self,self.R,priority
363
364 s=SimulationStep()
365 s.initialize()
366 Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
367 J5 = Job(name="job 5",server=Rp,sim=s)
368 J6 = Job(name="job 6",server=Rp,sim=s)
369 J7 = Job(name="job 7",server=Rp,sim=s)
370 s.activate(J5,J5.execute(priority=2))
371 s.activate(J6,J6.execute(priority=4))
372 s.activate(J7,J7.execute(priority=3))
373 s.simulate(until=100)
374 assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
375 %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
376
378 """Test PriorityQ, with preemption, capacity == 1"""
379 class nuJob(Process):
380 def __init__(self,name = "", sim=None):
381 Process.__init__(self, name = name, sim = sim)
382
383 def execute(self,res,priority):
384 self.preempt=len(res.activeQ) > 0\
385 and priority > res.activeQ[-1]._priority[res]
386 t=self.sim.now()
387 yield request,self,res,priority
388 if self.preempt:
389 assert len(res.waitQ) == 1, \
390 "No preemption activeQ= %s"%res.activeQ[0].name
391 yield hold,self,30
392 t1=self.sim.now()
393 if self.preempt:
394 assert t+30 == t1,\
395 "Wrong completion time for preemptor %s"%self.name
396 else:
397 assert t+60 == t1,\
398 "Wrong completion time for preempted %s %s:"\
399 %(self.name, self.sim.now())
400 yield release,self,res
401
402 s = SimulationStep()
403 s.initialize()
404 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
405 sim=s)
406 n1=nuJob(name="nuJob 1",sim=s)
407 n2=nuJob(name="nuJob 2",sim=s)
408 s.activate(n1,n1.execute(res,priority=0))
409 s.activate(n2,n2.execute(res,priority=1),at=15)
410 s.simulate(until=100)
411
413 """Test preemption of preemptor"""
414 class nuJob(Process):
415 seqOut=[]
416 def __init__(self,name="",sim=None):
417 Process.__init__(self, name = name, sim = sim)
418 self.serviceTime=30
419
420 def execute(self,res,priority):
421 self.preempt=len(res.activeQ) > 0\
422 and priority > res.activeQ[-1]._priority[res]
423 nrwaiting=len(res.waitQ)
424 yield request,self,res,priority
425 if self.preempt:
426 assert len(res.waitQ) == nrwaiting + 1,\
427 "No preemption activeQ= %s"%res.activeQ[0].name
428 yield hold,self,self.serviceTime
429 yield release,self,res
430 nuJob.seqOut.append((self,self.sim.now()))
431
432 s=SimulationStep()
433 s.initialize()
434 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
435 sim=s)
436 n1=nuJob(name="nuJob 1",sim=s)
437 n2=nuJob(name="nuJob 2",sim=s)
438 n3=nuJob(name="nuJob 3",sim=s)
439 s.activate(n1,n1.execute(res,priority=-1))
440 start2=10
441 s.activate(n2,n2.execute(res,priority=0),at=start2)
442 start3=20
443 s.activate(n3,n3.execute(res,priority=1),at=start3)
444 s.simulate(until=100)
445 assert [x[1] for x in nuJob.seqOut]\
446 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
447 "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
448
450 """Test that a process can preempt another process holding multiple resources
451 """
452 class Requestor(Process):
453 def run(self,res1,res2,res3,priority=1):
454 yield request,self,res1,priority
455 yield request,self,res2,priority
456 yield request,self,res3,priority
457 record.observe(t=s.now(),y=self.name)
458 yield hold,self,100
459 record.observe(t=s.now(),y=self.name)
460 yield release,self,res3
461 yield release,self,res2
462 yield release,self,res1
463
464 s=SimulationStep()
465 s.initialize()
466 outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
467 inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
468 innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
469 sim=s)
470 record=Monitor(sim=s)
471 r1=Requestor("r1",sim=s)
472 s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
473 r2=Requestor("r2",sim=s)
474 s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
475 at=50)
476 s.simulate(until=200)
477 assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
478 "was %s; preempt did not work"%record
479
481 """ test monitoring of number in the two queues, waitQ and activeQ
482 """
483 class Job(Process):
484 def __init__(self,name='',sim=None):
485 Process.__init__(self,name = name,sim = sim)
486
487 def execute(self,res):
488 yield request,self,res
489 yield hold,self,2
490 yield release,self,res
491
492 s=SimulationStep()
493 s.initialize()
494 res=Resource(name="server",capacity=1,monitored=1,sim=s)
495 n1=Job(name="Job 1",sim=s)
496 n2=Job(name="Job 2",sim=s)
497 n3=Job(name="Job 3",sim=s)
498 s.activate(n1,n1.execute(res),at=2)
499 s.activate(n2,n2.execute(res),at=2)
500 s.activate(n3,n3.execute(res),at=2)
501 s.simulate(until=100)
502 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
503 'Wrong waitMon:%s'%res.waitMon
504 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
505 'Wrong actMon:%s'%res.actMon
506 self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/6.0,2,
507 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
508
510 suite = unittest.TestSuite()
511 testInit = makeResourcetestcase("testInit")
512 testrequest = makeResourcetestcase("testrequest")
513 testrequest2 = makeResourcetestcase("testrequest2")
514 testrequest3 = makeResourcetestcase("testrequest3")
515 testrequest4 = makeResourcetestcase("testrequest4")
516 testrequestPriority = makeResourcetestcase("testrequestPriority")
517 testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
518 testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
519 testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
520 testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
521 testmonitored = makeResourcetestcase("testmonitored")
522
523 suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
524 testrequestPriority,testrequestPriority1,
525 testrequestPriority2,testrequestPriority3,
526 testrequestNestedPreempt,
527 testmonitored])
528 return suite
529
530
531
532
533
537
538 - def breakin(self,waitbefore,howoften=1):
539 for i in range(howoften):
540 yield hold,self,waitbefore
541 self.interrupt(victim)
542
546
548 global igothit
549 igothit={}
550 while self.sim.now()<=theEnd:
551 yield hold,self,howlong
552 if self.interrupted():
553 byWhom=self.interruptCause
554 igothit[self.sim.now()]=byWhom
555 else:
556 pass
557
559 """
560 Tests interrupts as defined in SEP001v17
561 """
576
577
578
594
608
610 """
611 Test multiple interrupts by multiple processes during victim activity
612 """
613 global victim
614 s=SimulationStep()
615 s.initialize()
616 breaker1=Interruptor(sim=s)
617 s.activate(breaker1,breaker1.breakin(15,howoften=3))
618 breaker2=Interruptor(sim=s)
619 s.activate(breaker2,breaker2.breakin(20,howoften=3))
620 victim=Interrupted(sim=s)
621 s.activate(victim,victim.myActivity(100))
622 s.simulate(until=200)
623 for i in (15,30,45):
624 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
625 for i in (20,40,60):
626 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
627 assert len(igothit) == 6 , "Interrupted wrong number of times"
628
646
647 victim.newProcess=newProcess
648 s.activate(victim,newProcess(victim))
649 s.activate(breaker,breaker.breakin(10,howoften=3))
650 s.simulate(until=1000)
651
662
663
664
665
666
678
682
684 assert p.active(),"p not active"
685 assert not p.passive(), "p passive"
686 assert not p.terminated(),"p terminated"
687 assert not p.interrupted(),"p interrupted"
688 yield hold,self,11
689 assert not p.active(),"p active"
690 assert not p.passive(),"p passive"
691 assert p.terminated(),"p not terminated"
692 assert not p.interrupted(),"p interrupted"
693
695 assert not p.active(),"p active"
696 assert p.passive(),"p not passive"
697 assert not p.terminated(),"p not terminated"
698 assert not p.interrupted(),"p interrupted"
699 self.sim.activate(p,p.life1())
700 yield hold,self,11
701 assert not p.active(),"p active"
702 assert not p.passive(),"p not passive"
703 assert p.terminated(),"p not terminated"
704 assert not p.interrupted(),"p interrupted"
705
707 assert not p.active(),"p active"
708 assert p.passive(),"p not passive"
709 assert not p.terminated(),"p not terminated"
710 assert not p.interrupted(),"p interrupted"
711 self.sim.activate(p,p.life2())
712 yield hold,self,11
713 assert not p.active(),"p active"
714 assert p.passive(),"p not passive"
715 assert not p.terminated(),"p terminated"
716 assert not p.interrupted(),"p interrupted"
717
719 yield hold,self,5
720 assert p.active(),"p not active"
721 assert not p.passive(),"p passive"
722 assert not p.terminated(),"p terminated"
723 assert not p.interrupted(),"p interrupted"
724 self.cancel(p)
725 assert not p.active(),"p active"
726 assert p.passive(),"p not passive"
727 assert not p.terminated(),"p terminated"
728 assert not p.interrupted(),"p interrupted"
729 self.sim.reactivate(p)
730 assert p.active(),"p not active"
731 assert not p.passive(),"p passive"
732 assert not p.terminated(),"p terminated"
733 assert not p.interrupted(),"p interrupted"
734 yield hold,self
735 assert not p.active(),"p active"
736 assert not p.passive(),"p passive"
737 assert p.terminated(),"p terminated"
738 assert not p.interrupted(),"p interrupted"
739
741 yield hold,self,11
742 assert not p.active(),"p active"
743 assert p.passive(),"p not passive"
744 assert not p.terminated(),"p terminated"
745 assert not p.interrupted(),"p interrupted"
746 self.cancel(p)
747 assert not p.active(),"p active"
748 assert p.passive(),"p not passive"
749 assert not p.terminated(),"p terminated"
750 assert not p.interrupted(),"p interrupted"
751
769
773
774 - def look1(self,p1,p2,res):
775 assert p1.active(), "p1 not active"
776 assert not p1.queuing(res), "p1 queuing"
777 assert p2.active(), "p2 not active"
778 assert not p2.queuing(res), "p2 queuing"
779 yield hold,self,2
780 assert p1.active(), "p1 not active"
781 assert not p1.queuing(res), "p1 queuing"
782 assert p2.passive(), "p2 active"
783 assert p2.queuing(res), "p2 not queuing"
784
793
795 """
796 Tests states and state transitions as defined in SEP003
797 """
798
811
830
852
854 """
855 Test request/release state transitions
856 """
857
858 s=SimulationStep()
859 s.initialize()
860 res=Resource(capacity=1,sim=s)
861 pq1=PS2(sim=s)
862 s.activate(pq1,pq1.life1(res))
863 pq2=PS2(sim=s)
864 s.activate(pq2,pq2.life1(res))
865 obq1=Observer2(sim=s)
866 s.activate(obq1,obq1.look1(pq1,pq2,res))
867 s.simulate(until=12)
868
869
870 s=SimulationStep()
871 s.initialize()
872 res=Resource(capacity=1,sim=s)
873 pq3=PS2(sim=s)
874 s.activate(pq3,pq3.life2(res))
875 obq2=Observer2(sim=s)
876 s.activate(obq2,obq2.look2(pq3,res),prior=True)
877 s.simulate(until=12)
878
888
889
890
891
892
897 yield hold,self,1
898 ev1.signal("from SignalProcess")
899 while ev2.queues:
900 nq0=len(ev2.queues)
901 ev2.signal("from SignalProcess")
902 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
903
908 yield waitevent,self,ev1
909 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
910 assert ev1 in self.eventsFired,"did not record firing event"
911
916 yield queueevent,self,ev2
917 assert ev2 in self.eventsFired,"did not record firing event"
918
921 yield hold,self,1
922 ev1.signal("from SignalProcess")
923 yield hold,self,3
924 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
925 while ev2.queues:
926 nq0=len(ev2.queues)
927 ev2.signal("from SignalProcess")
928 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
929 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
930
935 yield waitevent,self,evset
936 for e in evset:
937 assert e.waits==[],"process not out of waiting list for all events in OR"
938
949
950
952 nrProcesses=0
957 yield queueevent,self,evset
958 occurred=False
959 for e in evset:
960 occurred=occurred or (e in self.eventsFired)
961 assert occurred,"queuing process activated by wrong event(s)"
962
974
976 """
977 Test SimEvent/signal as introduced with SimPy 1.5
978 """
979
981 """
982 Tests basic signal semantics
983 """
984 s=SimulationStep()
985 s.initialize()
986 e=SimEvent(sim=s)
987 e.signal("param")
988 assert e.occurred,"signal does not set 'occurred' to True"
989 assert e.signalparam=="param","signal parameter wrong"
990 e.signal()
991 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
992 e.signal()
993 assert e.occurred,"multiple calls to signal do not set 'occurred'"
994
1011
1013 """
1014 Tests waiting, queuing for at least one event out of a list/tuple.
1015 """
1016 si=SimulationStep()
1017 si.initialize()
1018 e1=SimEvent("e1",sim=si)
1019 e2=SimEvent("e2",sim=si)
1020 e3=SimEvent("e3",sim=si)
1021 s=SignalProcessOR(sim=si)
1022 si.activate(s,s.makeSignal(e1,e3))
1023 w=WaitProcessOR(sim=si)
1024 si.activate(w,w.waitForSig([e1,e2]))
1025 for i in range(5):
1026 q=QueueProcessOR(sim=si)
1027 si.activate(q,q.queueForSig([e2,e3]))
1028 si.simulate(until=10)
1029
1038
1047
1058
1059
1060
1061
1062
1067 global a,b,c
1068 a=True
1069 yield hold,self,1
1070 b=True
1071 yield hold,self,1
1072 c=True
1073 yield hold,self,1
1074 assert waiter.terminated(),"waituntil did not fire"
1075
1080 def waitcond():
1081 return a and b and c
1082 yield waituntil,self,waitcond
1083
1085 """
1086 Test waituntil as introduced with SimPy 1.5
1087 """
1088
1099
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1117 """ Job class for testing timeout reneging
1118 """
1119 - def __init__(self,server=None,name="",sim=None):
1123
1124 - def execute(self,timeout,usetime):
1125 yield (request,self,self.res),(hold,self,timeout)
1126 if self.acquired(self.res):
1127 self.gotResource=True
1128 yield hold,self,usetime
1129 yield release,self,self.res
1130 else:
1131 self.gotResource=False
1132
1134 """ Job class for testing timeout reneging with priorities
1135 """
1136 - def __init__(self,server=None,name="",sim=None):
1140
1141 - def execute(self,timeout,usetime,priority):
1142 yield (request,self,self.res,priority),(hold,self,timeout)
1143 if self.acquired(self.res):
1144 self.gotResource=True
1145 yield hold,self,usetime
1146 yield release,self,self.res
1147 else:
1148 self.gotResource=False
1149
1151 """ Tests of "yield (request,self,res),(hold,self,delay)"
1152 timeout reneging command
1153 """
1155 """Test that resource gets acquired without timeout
1156 """
1157
1158 s=SimulationStep()
1159 s.initialize()
1160 res=Resource(name="Server",capacity=1,sim=s)
1161 usetime=5
1162 timeout=1000000
1163 j1=JobTO(server=res,name="Job_1",sim=s)
1164 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1165 j2=JobTO(server=res,name="Job_2",sim=s)
1166 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1167 s.simulate(until=2*usetime)
1168 assert s.now()==2*usetime,"time not ==2*usetime"
1169 assert j1.gotResource and j2.gotResource,\
1170 "at least one job failed to get resource"
1171 assert not (res.waitQ or res.activeQ),\
1172 "job waiting or using resource"
1173
1175 """Test that resource gets acquired without timeout.
1176 Resource monitored.
1177 """
1178
1179 s=SimulationStep()
1180 s.initialize()
1181 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1182 usetime=5
1183 timeout=1000000
1184 j1=JobTO(server=res,name="Job_1",sim=s)
1185 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1186 j2=JobTO(server=res,name="Job_2",sim=s)
1187 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1188 s.simulate(until=2*usetime)
1189 assert s.now()==2*usetime,"time not ==2*usetime"
1190 assert j1.gotResource and j2.gotResource,\
1191 "at least one job failed to get resource"
1192 assert not (res.waitQ or res.activeQ),\
1193 "job waiting or using resource"
1194 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1195
1197 """Test that timeout occurs when resource busy
1198 """
1199
1200 s=SimulationStep()
1201 s.initialize()
1202 res=Resource(name="Server",capacity=1,sim=s)
1203 usetime=5
1204 timeout=3
1205 j1=JobTO(server=res,name="Job_1",sim=s)
1206 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1207 j2=JobTO(server=res,name="Job_2",sim=s)
1208 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1209 s.simulate(until=2*usetime)
1210 assert(s.now()==usetime),"time not ==usetime"
1211 assert(j1.gotResource),"Job_1 did not get resource"
1212 assert(not j2.gotResource),"Job_2 did not renege"
1213 assert not (res.waitQ or res.activeQ),\
1214 "job waiting or using resource"
1215
1217 """Test that timeout occurs when resource busy.
1218 Resource monitored.
1219 """
1220 s=SimulationStep()
1221 s.initialize()
1222 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1223 usetime=5
1224 timeout=3
1225 j1=JobTO(server=res,name="Job_1",sim=s)
1226 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1227 j2=JobTO(server=res,name="Job_2",sim=s)
1228 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1229 s.simulate(until=2*usetime)
1230 assert(s.now()==usetime),"time not == usetime"
1231 assert(j1.gotResource),"Job_1 did not get resource"
1232 assert(not j2.gotResource),"Job_2 did not renege"
1233 assert not (res.waitQ or res.activeQ),\
1234 "job waiting or using resource"
1235 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1236
1238 """Test that timeout occurs when resource busy.
1239 Resource monitored. Requests with priority and preemption.
1240 """
1241 s=SimulationStep()
1242 s.initialize()
1243 res=Resource(name="Server",capacity=1,monitored=True,
1244 qType=PriorityQ,preemptable=True,sim=s)
1245 usetime=5
1246 timeout=3
1247 j1=JobTO_P(server=res,name="Job_1",sim=s)
1248 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1249 j2=JobTO_P(server=res,name="Job_2",sim=s)
1250 j2_arrival=1
1251 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
1252 at=j2_arrival)
1253 j3=JobTO_P(server=res,name="Job_2",sim=s)
1254 j3_arrival=2
1255 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
1256 at=j3_arrival)
1257 s.simulate(until=3*usetime)
1258 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1259 assert(j1.gotResource),"Job_1 did not get resource"
1260 assert(j2.gotResource),"Job_2 did renege"
1261 assert(j2.gotResource),"Job_3 did renege"
1262 assert not (res.waitQ or res.activeQ),\
1263 "job waiting or using resource"
1264 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1265 "res.waitMon wrong: %s"%res.waitMon
1266
1268 """Test that timeout occurs when resource has no capacity free
1269 """
1270
1271 s=SimulationStep()
1272 s.initialize()
1273 res=Resource(name="Server",capacity=0,sim=s)
1274 usetime=5
1275 timeout=3
1276 j1=JobTO(server=res,name="Job_1",sim=s)
1277 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1278 j2=JobTO(server=res,name="Job_2",sim=s)
1279 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1280 s.simulate(until=2*usetime)
1281 assert s.now()==timeout,"time %s not == timeout"%s.now()
1282 assert not j1.gotResource,"Job_1 got resource"
1283 assert not j2.gotResource,"Job_2 got resource"
1284 assert not (res.waitQ or res.activeQ),\
1285 "job waiting or using resource"
1286
1288 """Test that timeout occurs when resource has no capacity free.
1289 Resource monitored.
1290 """
1291
1292 s=SimulationStep()
1293 s.initialize()
1294 res=Resource(name="Server",capacity=0,monitored=True,sim=s)
1295 usetime=5
1296 timeout=3
1297 j1=JobTO(server=res,name="Job_1",sim=s)
1298 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1299 j2=JobTO(server=res,name="Job_2",sim=s)
1300 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1301 s.simulate(until=2*usetime)
1302 assert s.now()==timeout,"time %s not == timeout"%s.now()
1303 assert not j1.gotResource,"Job_1 got resource"
1304 assert not j2.gotResource,"Job_2 got resource"
1305 assert not (res.waitQ or res.activeQ),\
1306 "job waiting or using resource"
1307 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1308 "res.waitMon is wrong: %s"%res.waitMon
1309
1323
1324
1325
1326
1327
1328
1329
1330
1332 """ Job class for testing event reneging
1333 """
1334 - def __init__(self,server=None,name="",sim=None):
1338
1340 yield (request,self,self.res),(waitevent,self,event)
1341 if self.acquired(self.res):
1342 self.gotResource=True
1343 yield hold,self,usetime
1344 yield release,self,self.res
1345 else:
1346 self.gotResource=False
1347
1349 """ Job class for testing event reneging with multi-event lists
1350 """
1351 - def __init__(self,server=None,name="",sim=None):
1355
1356 - def execute(self,eventlist,usetime):
1357 yield (request,self,self.res),(waitevent,self,eventlist)
1358 if self.acquired(self.res):
1359 self.gotResource=True
1360 yield hold,self,usetime
1361 yield release,self,self.res
1362 else:
1363 self.gotResource=False
1364
1366 """Fires reneging event
1367 """
1370 - def fire(self,fireDelay,event):
1371 yield hold,self,fireDelay
1372 event.signal()
1373
1375 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1376 event reneging command
1377 """
1379 """Test that processes acquire resource normally if no event fires
1380 """
1381 s=SimulationStep()
1382 s.initialize()
1383 event=SimEvent("Renege_trigger",sim=s)
1384 res=Resource(name="Server",capacity=1,sim=s)
1385 usetime=5
1386 j1=JobEvt(server=res,name="Job_1",sim=s)
1387 s.activate(j1,j1.execute(event=event,usetime=usetime))
1388 j2=JobEvt(server=res,name="Job_2",sim=s)
1389 s.activate(j2,j2.execute(event=event,usetime=usetime))
1390 s.simulate(until=2*usetime)
1391
1392 assert s.now()==2*usetime,"time not ==2*usetime"
1393 assert j1.gotResource and j2.gotResource,\
1394 "at least one job failed to get resource"
1395 assert not (res.waitQ or res.activeQ),\
1396 "job waiting or using resource"
1397
1399 """Test that processes acquire resource normally if no event fires.
1400 Resource monitored.
1401 """
1402 s=SimulationStep()
1403 s.initialize()
1404 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1405 event=SimEvent("Renege_trigger",sim=s)
1406 usetime=5
1407 j1=JobEvt(server=res,name="Job_1",sim=s)
1408 s.activate(j1,j1.execute(event=event,usetime=usetime))
1409 j2=JobEvt(server=res,name="Job_2",sim=s)
1410 s.activate(j2,j2.execute(event=event,usetime=usetime))
1411 s.simulate(until=2*usetime)
1412
1413 assert s.now()==2*usetime,"time not ==2*usetime"
1414 assert j1.gotResource and j2.gotResource,\
1415 "at least one job failed to get resource"
1416 assert not (res.waitQ or res.activeQ),\
1417 "job waiting or using resource"
1418 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1419
1421 """Test that signalled event leads to renege when resource busy
1422 """
1423
1424 s=SimulationStep()
1425 s.initialize()
1426 res=Resource(name="Server",capacity=1,sim=s)
1427 event=SimEvent("Renege_trigger",sim=s)
1428 usetime=5
1429 eventtime=1
1430 j1=JobEvt(server=res,name="Job_1",sim=s)
1431 s.activate(j1,j1.execute(event=event,usetime=usetime))
1432 j2=JobEvt(server=res,name="Job_2",sim=s)
1433 s.activate(j2,j2.execute(event=event,usetime=usetime))
1434 f=FireEvent(name="FireEvent",sim=s)
1435 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1436 s.simulate(until=2*usetime)
1437
1438 assert(s.now()==usetime),"time not ==usetime"
1439 assert(j1.gotResource),"Job_1 did not get resource"
1440 assert(not j2.gotResource),"Job_2 did not renege"
1441 assert not (res.waitQ or res.activeQ),\
1442 "job waiting or using resource"
1443
1445 """Test that signalled event leads to renege when resource busy.
1446 Resource monitored.
1447 """
1448
1449 s=SimulationStep()
1450 s.initialize()
1451 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1452 event=SimEvent("Renege_trigger",sim=s)
1453 usetime=5
1454 eventtime=1
1455 j1=JobEvt(server=res,name="Job_1",sim=s)
1456 s.activate(j1,j1.execute(event=event,usetime=usetime))
1457 j2=JobEvt(server=res,name="Job_2",sim=s)
1458 s.activate(j2,j2.execute(event=event,usetime=usetime))
1459 f=FireEvent(name="FireEvent",sim=s)
1460 s.activate(f,f.fire(fireDelay=eventtime,event=event))
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 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1469
1471 """Test that renege-triggering event can be one of an event list
1472 """
1473
1474 s=SimulationStep()
1475 s.initialize()
1476 res=Resource(name="Server",capacity=1,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
1498 """Test that renege-triggering event can be one of an event list.
1499 Resource monitored.
1500 """
1501
1502 s=SimulationStep()
1503 s.initialize()
1504 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1505 event1=SimEvent("Renege_trigger_1",sim=s)
1506 event2=SimEvent("Renege_trigger_2",sim=s)
1507 usetime=5
1508 eventtime=1
1509 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1510 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1511 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1512 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1513 f1=FireEvent(name="FireEvent_1",sim=s)
1514 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1515 f2=FireEvent(name="FireEvent_2",sim=s)
1516 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1517 s.simulate(until=2*usetime)
1518
1519 assert(s.now()==usetime),"time not ==usetime"
1520 assert(j1.gotResource),"Job_1 did not get resource"
1521 assert(not j2.gotResource),"Job_2 did not renege"
1522 assert not (res.waitQ or res.activeQ),\
1523 "job waiting or using resource"
1524 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1525
1538
1539
1540
1541
1542
1543
1545 produced=0
1554 """PriorityQ for Producers"""
1555 Producer.produced+=4
1556 yield put,self,buffer,4,priority
1557 yield hold,self,1
1558 self.done=self.sim.now()
1559 doneList.append(self.name)
1561 for i in range(4):
1562 yield put,self,buffer,4
1563 yield hold,self,1
1565 consumed=0
1569 """FIFO"""
1570 yield get,self,buffer
1571 Consumer.consumed+=1
1572 assert self.got==1,"wrong self.got: %s"%self.got
1573 yield get,self,buffer,3
1574 Consumer.consumed+=3
1575 assert self.got==3,"wrong self.got: %s"%self.got
1576
1578 """producer PriorityQ, consumer FIFO"""
1579 while True:
1580 yield get,self,buffer,2
1581 yield hold,self,1
1583 """PriorityQ for Consumers"""
1584 yield get,self,buffer,4,priority
1585 doneList.append(self.name)
1586
1587
1591 - def produce(self,buffer,productionTime):
1592 while True:
1593 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1594 "Consumer(s) waiting while buffer not empty"
1595 yield hold,self,productionTime
1596 yield put,self,buffer,1
1597
1601 - def consume(self,buffer,consumptionTime):
1602 while True:
1603 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1604 "Producer(s) waiting while buffer empty"
1605 yield get,self,buffer,1
1606 yield hold,self,consumptionTime
1607
1608
1609
1612 """Tests initialization of Level instances
1613 """
1614 s=SimulationStep()
1615 s.initialize()
1616 a=Level(sim=s)
1617 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1618 assert a.amount==0,"wrong buffer content: %s"%a
1619 assert a.name=="a_level","wrong name: %s"%a
1620 assert not a.monitored,"should not be monitored: %s"%a
1621 assert a.putQMon is None,"should not have putQMon: %s"%a
1622 assert a.getQMon is None,"should not have getQMon: %s"%a
1623 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1624 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1625 "putQType and getQType should be FIFO: %s"%a
1626
1627 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1628 putQType=PriorityQ,sim=s)
1629 a=Level(sim=s)
1630 assert b.capacity==12,"wrong capacity:%s"%b
1631 assert b.amount==10,"wrong buffer content: %s"%b
1632 assert b.name=="b","wrong name: %s"%b
1633 assert b.monitored,"should be monitored: %s"%b
1634 assert not (b.putQMon is None),"should have putQMon: %s"%b
1635 assert not (b.getQMon is None),"should have getQMon: %s"%b
1636 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1637 assert b.putQType.__name__=="PriorityQ",\
1638 "putQType should be PriorityQ: %s"%b
1639 assert b.getQType.__name__=="FIFO",\
1640 "getQType should be PriorityQ: %s"%b
1641
1643 """Level: tests basic Producer/Consumer principles:
1644 - Consumers must not be waiting while Level buffer value > 0,
1645 - Producers must not be waiting while Level buffer value == 0
1646 """
1647 s=SimulationStep()
1648 s.initialize()
1649 bufferSize=1
1650 productionTime=1
1651 consumptionTime=5
1652 endtime=50
1653 buffer=Level(capacity=bufferSize,sim=s)
1654 consumer=ConsumerPrincL(sim=s)
1655 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1656 producer=ProducerPrincL(sim=s)
1657 s.activate(producer,producer.produce(buffer,productionTime))
1658 s.simulate(until=endtime)
1659
1673
1691
1693 """Level: tests put/get in multiple Producer/Consumer scenario,
1694 with Producers having different priorities.
1695 How: Producers forced to queue; all after first should be done in
1696 priority order
1697 """
1698 global doneList
1699 doneList=[]
1700 s=SimulationStep()
1701 s.initialize()
1702 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1703 for i in range(4):
1704 p=Producer(str(i), sim=s)
1705 pPriority=i
1706 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1707 c=Consumer(sim=s)
1708 s.activate(c,c.consume1(buffer=buffer))
1709 s.simulate(until=100)
1710 assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
1711 %doneList
1712
1714 """Level: tests put/get in multiple Producer/Consumer scenario, with
1715 Consumers having different priorities.
1716 How: Consumers forced to queue; all after first should be done in
1717 priority order
1718 """
1719 global doneList
1720 doneList=[]
1721 s=SimulationStep()
1722 s.initialize()
1723 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1724 for i in range(4):
1725 c=Consumer(str(i), sim=s)
1726 cPriority=i
1727 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1728 p=Producer(sim=s)
1729 s.activate(p,p.produce1(buffer=buffer))
1730 s.simulate(until=100)
1731 assert doneList==["3","2","1","0"],"gets were not done in priority order: %s"\
1732 %doneList
1733
1745
1746
1747
1748
1749
1750
1751
1776
1804
1808
1810 """Sorts Widget instances by weight attribute."""
1811 tmplist=[(x.weight,x) for x in par]
1812 tmplist.sort()
1813 return [x for (key,x) in tmplist]
1814
1815
1819 - def produce(self,buffer,productionTime):
1820 while True:
1821 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1822 "Consumer(s) waiting while buffer not empty"
1823 yield hold,self,productionTime
1824 product=WidgetPrinc()
1825 yield put,self,buffer,[product]
1826
1830 - def consume(self,buffer,consumptionTime):
1831 while True:
1832 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1833 "Producer(s) waiting while buffer empty"
1834 yield get,self,buffer,1
1835 yield hold,self,consumptionTime
1836
1839
1841 """Used in testBufferFilter"""
1847
1849 """get all items with weight between a and b"""
1850 def between_a_and_b(buf):
1851 res=[]
1852 for item in buf:
1853 if a<item.weight<b:
1854 res.append(item)
1855
1856 all=store.buffered
1857 yield get,self,store,between_a_and_b
1858 "All retrieved items weight in range?"
1859 for it in self.got:
1860 assert a<it.weight<b,"weight %s not in range %s..%s"\
1861 %(it.weight,a,b)
1862 "Any item fitting filter pred left in buffer?"
1863 for it in store.buffer:
1864 assert not (a<it.weight<b),\
1865 "item left in buffer which fits filter (%s<%s<%s)"\
1866 %(a,it.weight,b)
1867 "All items either in store.buffer of self.got?"
1868 for it in all:
1869 assert (it in self.buffer) or (it in self.got),\
1870 "item w. weight %s neither in store nor in got"%it.weight
1871
1872
1873
1876 """Store: tests initialization of Store instances
1877 """
1878 s=SimulationStep()
1879 s.initialize()
1880 a=Store(sim=s)
1881 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1882 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1883 assert a.name=="a_store","wrong name: %s"%a
1884 assert not a.monitored,"should not be monitored: %s"%a
1885 assert a.putQMon is None,"should not have putQMon: %s"%a
1886 assert a.getQMon is None,"should not have getQMon: %s"%a
1887 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1888 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1889 "putQType and getQType should be FIFO: %s"%a
1890
1891 stored=[Widget(weight=5)]*10
1892 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1893 putQType=PriorityQ,sim=s)
1894 assert b.capacity==12,"wrong capacity:%s"%b
1895 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1896 assert b.name=="b","wrong name: %s"%b
1897 assert b.monitored,"should be monitored: %s"%b
1898 assert not (b.putQMon is None),"should have putQMon: %s"%b
1899 assert not (b.getQMon is None),"should have getQMon: %s"%b
1900 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1901 assert b.putQType.__name__=="PriorityQ",\
1902 "putQType should be PriorityQ: %s"%b
1903 assert b.getQType.__name__=="FIFO",\
1904 "getQType should be PriorityQ: %s"%b
1905
1907 """Store: tests basic Producer/Consumer principles:
1908 - Consumers must not be waiting while items in Store buffer,
1909 - Producers must not be waiting while space available in Store buffer
1910 """
1911 bufferSize=1
1912 productionTime=1
1913 consumptionTime=5
1914 endtime=50
1915 s=SimulationStep()
1916 s.initialize()
1917 buffer=Store(capacity=bufferSize,sim=s)
1918 consumer=ConsumerPrincS(sim=s)
1919 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1920 producer=ProducerPrincS(sim=s)
1921 s.activate(producer,producer.produce(buffer,productionTime))
1922 s.simulate(until=endtime)
1923
1938
1956
1958 """Store: Tests put/get in multiple Producer/Consumer scenario,
1959 with Producers having different priorities.
1960 How; Producers forced to queue; all after first should be done in
1961 priority order
1962 """
1963 global doneList
1964 doneList=[]
1965 s=SimulationStep()
1966 s.initialize()
1967 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1968 for i in range(4):
1969 p=ProducerWidget(name=str(i), sim=s)
1970 pPriority=i
1971 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1972 c=ConsumerWidget(sim=s)
1973 s.activate(c,c.consume1(buffer=buffer))
1974 s.simulate(until=100)
1975 assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
1976 %doneList
1977
1979 """Tests put/get in multiple Producer/Consumer scenario, with
1980 Consumers having different priorities.
1981 How; Consumers forced to queue; all after first should be done in
1982 priority order
1983 """
1984 global doneList
1985 doneList=[]
1986 s=SimulationStep()
1987 s.initialize()
1988 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1989 for i in range(4):
1990 c=ConsumerWidget(name=str(i),sim=s)
1991 cPriority=i
1992 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1993 p=ProducerWidget(sim=s)
1994 s.activate(p,p.produce1(buffer=buffer))
1995 s.simulate(until=100)
1996 assert doneList==["3","2","1","0"],\
1997 "gets were not done in priority order: %s"%doneList
1998
2000 """Tests the optional sorting of theBuffer by applying a user-defined
2001 sort function."""
2002 s=SimulationStep()
2003 s.initialize()
2004 gotten=[]
2005 sortedStore=Store(sim=s)
2006 sortedStore.addSort(mySortFunc)
2007 p=ProducerWidget(sim=s)
2008 s.activate(p,p.produceUnordered(sortedStore))
2009 for i in range(9):
2010 c=ConsumerWidget(sim=s)
2011 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
2012 s.simulate(until=10)
2013 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
2014
2027
2042
2043
2044
2045
2046
2047
2048 -class TBT(Process):
2049 """Store: For testBasicTime"""
2052 - def tbt(self,store):
2053 yield get,self,store,1
2054 assert self.got,"Did not get Item"
2055 yield (get,self,store,1),(hold,self,5)
2056 if self.acquired(store):
2057 assert len(self.got)==1,"did not get 1 Item"
2058 else:
2059 assert not self.got and self.sim.now()==5 and not store.getQ,\
2060 "time renege not working"
2061
2062 -class TBE(Process):
2063 """Store: For testBasicEvent"""
2066 - def tbe(self,store,trigger):
2067 yield get,self,store,1
2068 assert self.got,"Did not get Item"
2069 yield (get,self,store,1),(waitevent,self,trigger)
2070 if self.acquired(store):
2071 assert False, "should have reneged"
2072 else:
2073 assert self.eventsFired[0]==trigger and self.sim.now()==5 \
2074 and not store.getQ,"event renege not working"
2075
2077 """Store: For testBasicEvent"""
2080 - def fire(self,trigger):
2083
2084
2086 """Store: for testBasicTimePut"""
2089 - def tbt(self,store):
2090 class Item:pass
2091 yield (put,self,store,[Item()]),(hold,self,4)
2092 if self.stored(store):
2093 assert store.nrBuffered==1 and not store.putQ,\
2094 "put did not execute"
2095 else:
2096 assert False,"should not have reneged"
2097 yield (put,self,store,[Item()]),(hold,self,5)
2098 if self.stored(store):
2099 assert False,"should have reneged"
2100 else:
2101 assert store.nrBuffered==1 and not store.putQ,\
2102 "renege not working correctly"
2103
2105 """Store: for testBasicEventPut"""
2108 - def tbe(self,store,trigger):
2109 class Item:pass
2110 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2111 if self.stored(store):
2112 assert store.nrBuffered==1 and not store.putQ,\
2113 "put did not execute"
2114 else:
2115 assert False,"should have not have reneged"
2116 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2117 if self.stored(store):
2118 assert False,"should have reneged"
2119 else:
2120 assert self.sim.now()==5 and self.eventsFired[0]==trigger\
2121 and not store.putQ,"renege not working correctly"
2122
2124 """Store: For testBasicEventPut"""
2127 - def fire(self,trigger):
2130
2132 """Store: Testcase for compound get statements"""
2133
2134
2135
2136
2137
2138
2149
2150
2151
2152
2153
2154
2164
2166 """Store (monitored):
2167 test monitors with 'yield (put,self,store),(hold,self,time)"""
2168 s=SimulationStep()
2169 s.initialize()
2170 st=Store(capacity=1,monitored=True,sim=s)
2171 t=TBTput(sim=s)
2172 s.activate(t,t.tbt(store=st))
2173 s.simulate(until=10)
2174
2175 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2176 %st.putQMon
2177
2178 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2179
2180
2181
2182
2183
2184
2198
2199
2200
2201
2202
2203
2216
2218 """Store (monitored):
2219 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2220 si=SimulationStep()
2221 si.initialize()
2222 s=SimEvent(sim=si)
2223 st=Store(capacity=1,monitored=True,sim=si)
2224 t=TBEtriggerPut(sim=si)
2225 si.activate(t,t.fire(trigger=s))
2226 tb=TBEput(sim=si)
2227 si.activate(tb,tb.tbe(store=st,trigger=s))
2228 si.simulate(until=10)
2229
2230 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2231 %st.putQMon
2232
2233 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2234
2250
2251
2252
2253
2254
2255
2257 """Level: For testBasicTime"""
2260 - def tbt(self,level):
2261 yield get,self,level,1
2262 assert self.got,"did not get 1 unit"
2263 yield (get,self,level,1),(hold,self,5)
2264 if self.acquired(level):
2265 assert self.got==1,"did not get 1 unit"
2266 else:
2267 assert not self.got and self.sim.now()==5,\
2268 "time renege not working"
2269
2271 """Level: For testBasicEvent"""
2274 - def tbe(self,level,trigger):
2275 yield get,self,level,1
2276 assert self.got,"did not get 1 unit"
2277 yield (get,self,level,1),(waitevent,self,trigger)
2278 if self.acquired(level):
2279 assert self.got==1,"did not get 1 Item"
2280 else:
2281 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
2282 "event renege not working"
2283
2285 """Level: For testBasicEvent"""
2288 - def fire(self,trigger):
2291
2293 """Level: For testBasicTimePut"""
2296 - def tbt(self,level):
2297 yield put,self,level,1
2298 assert level.amount,"did not put 1 unit"
2299 yield (put,self,level,1),(hold,self,5)
2300 if self.stored(level):
2301 assert False,"should have reneged"
2302 else:
2303 assert level.amount==1 and self.sim.now()==5,\
2304 "time renege not working"
2305
2307 """Level: For testBasicEventPut and testBasicEventPutM"""
2310 - def tbe(self,level,trigger):
2311 yield (put,self,level,1),(waitevent,self,trigger)
2312 if self.stored(level):
2313 assert level.amount==1,"did not put 1 unit"
2314 else:
2315 assert False,"should not have reneged"
2316 yield (put,self,level,1),(waitevent,self,trigger)
2317 if self.stored(level):
2318 assert False, "should have reneged"
2319 else:
2320 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
2321 "renege not working"
2322
2324 """Level: For testBasicEventPut"""
2327 - def fire(self,trigger):
2330
2332 """Level: Testcase for compound get and put statements"""
2333
2334
2335
2336
2337
2338
2349
2350
2351
2352
2353
2354
2364
2365
2366
2367
2368
2369
2382
2384 """Level (monitored):
2385 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2386 s=SimulationStep()
2387 s.initialize()
2388 l=Level(initialBuffered=1,monitored=True,sim=s)
2389 trig=SimEvent(sim=s)
2390 t=TBELev(sim=s)
2391 s.activate(t,t.tbe(level=l,trigger=trig))
2392 tr=TBEtriggerLev(sim=s)
2393 s.activate(tr,tr.fire(trigger=trig))
2394 s.simulate(until=10)
2395
2396 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2397 %l.getQMon
2398
2399 assert l.bufferMon==[[0,1],[0,0]],\
2400 "bufferMon not working: %s"%l.bufferMon
2401
2402
2403
2404
2405
2406
2419
2421 """Level (monitored):
2422 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2423 s=SimulationStep()
2424 s.initialize()
2425 l=Level(capacity=1,monitored=True,sim=s)
2426 trig=SimEvent(sim=s)
2427 t=TBELevPut(sim=s)
2428 s.activate(t,t.tbe(level=l,trigger=trig))
2429 tr=TBEtriggerLevPut(sim=s)
2430 s.activate(tr,tr.fire(trigger=trig))
2431 s.simulate(until=10)
2432 "First put succeeds, second reneges at t=5.5?"
2433 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2434 %l.putQMon
2435 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2436 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2437
2452
2453 if __name__ == '__main__':
2454 alltests = unittest.TestSuite((
2455 makeSSuite(),
2456 makeRSuite(),
2457 makeISuite(),
2458 makePSuite(),
2459 makeESuite(),
2460 makeWSuite(),
2461 makeTOSuite(),
2462 makeEvtRenegeSuite(),
2463 makeLevelSuite(),
2464 makeStoreSuite(),
2465 makeStoreCompSuite(),
2466 makeLevelCompSuite(),
2467 makeMSuite()
2468 ))
2469
2470 runner = unittest.TextTestRunner()
2471 runner.run(alltests)
2472
2473