Initial commit

models/seq_msgcopy/custom

@@ -0,0 +1,19 @@
+10 0.506034294764
+20 0.948657433192
+30 1.42975870768
+40 1.82872096697
+50 2.2391722997
+60 2.64200735092
+70 3.01364096006
+80 3.39310956001
+90 3.73884924253
+100 4.11678997676
+110 4.42927002907
+120 4.77132256826
+130 5.10997827848
+140 5.47678732872
+150 5.80288966497
+160 6.12459595998
+170 6.4208890597
+180 6.70486005147
+190 7.04497432709

models/seq_msgcopy/model.py

@@ -0,0 +1,101 @@
+import sys
+sys.path.append("../../src/")
+
+from infinity import INFINITY
+from simulator import Simulator
+from DEVS import *
+import random
+
+class Event:
+    def __init__(self, eventSize):
+        self.eventSize = eventSize
+
+    def copy(self):
+        return Event(self.eventSize)
+
+class ProcessorState:
+    def __init__(self):
+        self.event1_counter = INFINITY
+        self.event1 = None
+        self.queue = []
+
+class Processor(AtomicDEVS):
+    def __init__(self, name, randomta):
+        AtomicDEVS.__init__(self, name)
+        self.recv_event1 = self.addInPort("in_event1")
+        self.send_event1 = self.addOutPort("out_event1")
+        self.state = ProcessorState()
+        self.randomta = randomta
+                
+    def timeAdvance(self):
+        return self.state.event1_counter
+
+    def intTransition(self):
+        self.state.event1_counter -= self.timeAdvance()
+        if self.state.event1_counter == 0 and self.state.queue == []:
+            self.state.event1_counter = INFINITY
+            self.state.event1 = None
+        else:
+            self.state.event1 = self.state.queue.pop()
+            self.state.event1_counter = round(random.uniform(0.75, 1.25), 4) if self.randomta else 1.0
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.event1_counter -= self.elapsed
+        #Only one element, so exploit this
+        ev1 = inputs[self.recv_event1][0]
+        if self.state.event1 is not None:
+            self.state.queue.append(ev1)
+        else:
+            self.state.event1 = ev1
+            self.state.event1_counter = round(random.uniform(0.75, 1.25), 4) if self.randomta else 1.0
+        return self.state
+
+    def outputFnc(self):
+        return {self.send_event1: [self.state.event1]}
+
+class Generator(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Generator")
+        self.state = "gen_event1"
+        self.send_event1 = self.addOutPort("out_event1")
+                
+    def timeAdvance(self):
+        return 1
+
+    def intTransition(self):
+        return self.state
+
+    def outputFnc(self):
+        return {self.send_event1: [Event(1)]}
+
+class CoupledRecursion(CoupledDEVS):
+    def __init__(self, width, depth, randomta):
+        CoupledDEVS.__init__(self, "Coupled" + str(depth))
+        self.recv_event1 = self.addInPort("in_event1")
+        self.send_event1 = self.addOutPort("out_event1")
+
+        if depth > 1:
+            self.recurse = self.addSubModel(CoupledRecursion(width, depth-1, randomta))
+            self.connectPorts(self.recv_event1, self.recurse.recv_event1)
+
+        for i in range(width):
+            processor = self.addSubModel(Processor("Processor%s_%s" % (depth, i), randomta))
+            if i == 0:
+                if depth > 1:
+                    self.connectPorts(self.recurse.send_event1, processor.recv_event1)
+                else:
+                    self.connectPorts(self.recv_event1, processor.recv_event1)
+            else:
+                self.connectPorts(prev.send_event1, processor.recv_event1)
+            prev = processor
+        self.connectPorts(prev.send_event1, self.send_event1)
+
+class DEVStone(CoupledDEVS):
+    def __init__(self, width, depth, randomta):
+        random.seed(1)
+        CoupledDEVS.__init__(self, "DEVStone")
+        self.generator = self.addSubModel(Generator())
+        self.recurse = self.addSubModel(CoupledRecursion(width, depth, randomta))
+
+        self.connectPorts(self.generator.send_event1, self.recurse.recv_event1)

models/seq_msgcopy/none

@@ -0,0 +1,19 @@
+10 0.445321321487
+20 0.773019075394
+30 1.12926562627
+40 1.46307698886
+50 1.7856806914
+60 2.09773405393
+70 2.40428527196
+80 2.70385805766
+90 2.98536062241
+100 3.29675332705
+110 3.58182541529
+120 3.82686368624
+130 4.05639735858
+140 4.31303636233
+150 4.51363070806
+160 4.77272439003
+170 5.04404298464
+180 5.29783089956
+190 5.46840890249

models/seq_msgcopy/pickle

@@ -0,0 +1,19 @@
+10 1.00358859698
+20 1.92382335663
+30 2.82720160484
+40 3.70774459839
+50 4.53612359365
+60 5.34053929647
+70 6.15619564056
+80 6.89614343643
+90 7.59043272336
+100 8.32588434219
+110 8.97914838791
+120 9.70039463043
+130 10.3721116384
+140 10.9661087195
+150 11.5756855806
+160 12.1958549817
+170 12.8808970451
+180 13.4318759441
+190 13.938313961

models/seq_msgcopy/plot

@@ -0,0 +1,8 @@
+# The one with (nearly) no collisions
+set terminal postscript enhanced colour portrait size 6,6
+set out 'seq_msgcopy.eps'
+set key top left
+set title "DEVStone with different message copy methods"
+set xlabel "Models"
+set ylabel "Time (s)"
+plot 'seq_msgcopy/none' title 'No copy', 'seq_msgcopy/custom' title 'Custom copy', 'seq_msgcopy/pickle' title 'Default'

models/seq_msgcopy/timer.py

@@ -0,0 +1,37 @@
+import sys
+import random
+sys.path.append("../../src/")
+sizes = range(10, 200, 10)
+from simulator import Simulator
+import time
+iters = int(sys.argv[1])
+
+def runFunc(param):
+        f = open("seq_msgcopy/%s" % (param), 'w')
+        for size in sizes:
+            from model import DEVStone
+            total = 0.0
+            for _ in range(iters):
+                random.seed(1)
+                model = DEVStone(3, size, False)
+                sim = Simulator(model)
+                sim.setMessageCopy(param)
+                sim.setSchedulerHeapSet()
+                sim.setTerminationTime(1000)
+                start = time.time()
+                sim.simulate()
+                total += (time.time() - start)
+            f.write("%s %s\n" % (size, total/iters))
+            print("%s %s" % (size, total/iters))
+        f.close()
+
+allprocs = []
+for msgcopy in ['none', 'pickle', 'custom']:
+    allprocs.append(msgcopy)
+
+map(runFunc, allprocs)
+"""
+from multiprocessing import Pool
+p = Pool(3)
+p.map(runFunc, allprocs)
+"""