def __init__(self):
CoupledDEVS.__init__(self, "RemoteDCProcessor")
mod = self.addSubModel(CoupledProcessor(1, 1), 2)
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.connectPorts(self.inport, mod.inport)
self.connectPorts(mod.outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Layer2")
self.lower = self.addSubModel(DoubleLayer1())
self.inport1 = self.addInPort("inport1")
self.inport2 = self.addInPort("inport2")
self.connectPorts(self.inport1, self.lower.inport)
self.connectPorts(self.inport2, self.lower.inport)
def __init__(self):
CoupledDEVS.__init__(self, "System")
# Parametrization of a simple market
contracts = ['IBM']
# TODO: check that every contract has a unique string identifier
# each contract will have exactly one corresponding order book. TODO: parametrize the creation of each OB
market = self.addSubModel(Market(contracts))
# TODO: parametrize the creation of each Agent (simple vs. with intermediary vs. more complex, etc.)
agents = [self.addSubModel(SimpleAgentToJournal())]
# Subscribe agent to market journal
for agent in agents:
self.connectPorts(agent.out_journal, market.in_agent_journal)
# There are two types of agent:
# those that receive EVERY message from the market and can decide what to do with it and
# those that receive ONLY messages sent to him
for agent in agents:
if isinstance(agent, SimpleAgentToJournal):
self.connectPorts(market.out_journal_agent,
agent.in_next_orderbook)
self.connectPorts(market.out_regulator_agent,
agent.in_notify_order)
else:
# TODO: create specific port for this agent in the market coupled class
pass
def __init__(self):
CoupledDEVS.__init__(self, "MultiNested")
self.generator = self.addSubModel(Generator("Generator", 1))
self.processor1 = self.addSubModel(NestedProcessor("NProcessor1"), 1)
self.processor2 = self.addSubModel(NestedProcessor("NProcessor2"), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "DQueue")
self.generator = self.addSubModel(Generator())
self.queue1 = self.addSubModel(Queue())
self.queue2 = self.addSubModel(Queue())
self.connectPorts(self.generator.outport, self.queue1.inport)
self.connectPorts(self.generator.outport, self.queue2.inport)
def __init__(self, nodes, atomicsPerNode, iterations, percentageremotes):
CoupledDEVS.__init__(self, "PHOLD")
self.processors = []
have = 0
destinations = []
cntr = 0
totalAtomics = nodes * atomicsPerNode
procs = []
for node in range(nodes):
procs.append([])
for i in range(atomicsPerNode):
procs[-1].append(atomicsPerNode*node+i)
cntr = 0
global distributed
for e, i in enumerate(procs):
allnoi = []
for e2, j in enumerate(procs):
if e2 != e:
allnoi.extend(j)
for j in i:
inoj = list(i)
inoj.remove(j)
self.processors.append(self.addSubModel(HeavyPHOLDProcessor("Processor_%d" % cntr, iterations, totalAtomics, cntr, inoj, allnoi, percentageremotes), e if distributed else 0))
cntr += 1
# All nodes created, now create all connections
for i in range(len(self.processors)):
for j in range(len(self.processors)):
if i == j:
continue
self.connectPorts(self.processors[i].OPorts[j], self.processors[j].inport)
def __init__(self, ta):
CoupledDEVS.__init__(self, "DualChain")
self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
self.processor1 = self.addSubModel(CoupledProcessor(ta, 2), 2)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.generator.outport, self.processor2.inport)
def __init__(self, seed=1, fixPart=0.30, trashPart=0.15):
CoupledDEVS.__init__(self, "Factory")
self.cylinder = self.addSubModel(ObjectSource("Cylinder", 3))
self.cube = self.addSubModel(ObjectSource("Cube", 2))
self.preassembler = self.addSubModel(Preassembler())
self.assembler = self.addSubModel(Assembler(seed=seed+1))
self.inspector = self.addSubModel(Inspector(seed=seed, fixPart=fixPart, trashPart=trashPart))
self.accept = self.addSubModel(Accept())
self.fix = self.addSubModel(Fix())
self.trash = self.addSubModel(Trash())
self.stats = self.addSubModel(Statistics())
self.connectPorts(self.cylinder.object_out, self.preassembler.in_object)
self.connectPorts(self.cube.object_out, self.preassembler.in_object)
self.connectPorts(self.preassembler.out_product, self.assembler.in_product)
self.connectPorts(self.assembler.out_stats, self.stats.in_queueTimes)
self.connectPorts(self.assembler.out_product, self.inspector.in_product)
self.connectPorts(self.inspector.out_stats, self.stats.in_queueTimes)
self.connectPorts(self.inspector.out_accept, self.accept.in_product)
self.connectPorts(self.inspector.out_fix, self.fix.in_product)
self.connectPorts(self.fix.out_product, self.assembler.in_product)
self.connectPorts(self.inspector.out_trash, self.trash.in_product)
self.connectPorts(self.accept.out_product, self.stats.in_product)
self.connectPorts(self.trash.out_product, self.stats.in_product)
def __init__(self):
CoupledDEVS.__init__(self, "Layer2")
self.lower = self.addSubModel(DoubleLayer1())
self.inport1 = self.addInPort("inport1")
self.inport2 = self.addInPort("inport2")
self.connectPorts(self.inport1, self.lower.inport)
self.connectPorts(self.inport2, self.lower.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(RemoteDCProcessor(), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "RemoteDCProcessor")
mod = self.addSubModel(CoupledProcessor(1, 1), 2)
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.connectPorts(self.inport, mod.inport)
self.connectPorts(mod.outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Binary")
self.generator = self.addSubModel(CoupledGenerator(1.0, True))
self.processor1 = self.addSubModel(CoupledProcessor(0.6, 2))
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "ChainPeekPoke")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2))
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "ChainPeekPoke")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2))
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "OptimizableChain")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(RemoteDCProcessor(), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "MultiNested")
self.generator = self.addSubModel(Generator("Generator", 1))
self.processor1 = self.addSubModel(NestedProcessor("NProcessor1"), 1)
self.processor2 = self.addSubModel(NestedProcessor("NProcessor2"), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "DQueue")
self.generator = self.addSubModel(Generator())
self.queue1 = self.addSubModel(Queue())
self.queue2 = self.addSubModel(Queue())
self.connectPorts(self.generator.outport, self.queue1.inport)
self.connectPorts(self.generator.outport, self.queue2.inport)
def __init__(self, ta):
CoupledDEVS.__init__(self, "DualChain")
self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
self.processor1 = self.addSubModel(CoupledProcessor(ta, 2), 2)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.generator.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Binary")
self.generator = self.addSubModel(CoupledGenerator(1.0, True))
self.processor1 = self.addSubModel(CoupledProcessor(0.6, 2))
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Local")
self.generator = self.addSubModel(Generator("Generator", 1))
self.processor1 = self.addSubModel(CoupledProcessor(1, 2))
self.processor2 = self.addSubModel(CoupledProcessor(1, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "OptimizableChain")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Local")
self.generator = self.addSubModel(Generator("Generator", 1))
self.processor1 = self.addSubModel(CoupledProcessor(1, 2))
self.processor2 = self.addSubModel(CoupledProcessor(1, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.submodel = self.addSubModel(GeneratorDS())
self.submodel2 = self.addSubModel(Processor())
self.submodel3 = self.addSubModel(Processor())
self.connectPorts(self.submodel.outport, self.submodel2.inport)
self.connectPorts(self.submodel2.outport, self.submodel3.inport)
self.connectPorts(self.submodel.outport, self.submodel3.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.listener_A = self.addInPort("listener_A")
self.output_A = self.addOutPort("output_A")
self.mini = self.addSubModel(Mini())
self.connectPorts(self.listener_A, self.mini.listener_B)
self.connectPorts(self.mini.output_B, self.output_A)
def __init__(self):
CoupledDEVS.__init__(self, "ROOT")
self.gen = self.addSubModel(Generator())
self.proc1 = self.addSubModel(ZCoupledProcessor(1), 1)
self.proc2 = self.addSubModel(ZCoupledProcessor(2), 2)
self.connectPorts(self.gen.outport, self.proc1.inport)
self.connectPorts(self.gen.outport, self.proc2.inport, trans2)
def __init__(self, t_gen_event1 = 1):
CoupledDEVS.__init__(self, "CoupledGenerator")
self.generator = self.addSubModel(GeneratorNPP("Generator", t_gen_event1))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.connectPorts(self.inport, self.generator.inport)
self.connectPorts(self.generator.outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.submodel = self.addSubModel(GeneratorDS())
self.submodel2 = self.addSubModel(Processor())
self.submodel3 = self.addSubModel(Processor())
self.connectPorts(self.submodel.outport, self.submodel2.inport)
self.connectPorts(self.submodel2.outport, self.submodel3.inport)
self.connectPorts(self.submodel.outport, self.submodel3.inport)
def __init__(self):
CoupledDEVS.__init__(self, "ROOT")
self.gen = self.addSubModel(Generator())
self.proc1 = self.addSubModel(ZCoupledProcessor(1), 1)
self.proc2 = self.addSubModel(ZCoupledProcessor(2), 2)
self.connectPorts(self.gen.outport, self.proc1.inport)
self.connectPorts(self.gen.outport, self.proc2.inport, trans2)
def __init__(self, width):
CoupledDEVS.__init__(self, "Queue")
self.generator = self.addSubModel(Generator())
prev = self.generator
seeds = [i * 1000 for i in range(width)]
for i in range(width):
m = self.addSubModel(Processor("Processor%i" % i, seeds[i]))
self.connectPorts(prev.send_event1, m.recv_event1)
prev = m
def __init__(self):
CoupledDEVS.__init__(self, "Coupled")
self.generator = self.addSubModel(Generator())
self.processor1 = self.addSubModel(RandomProcessor(1))
self.processor2 = self.addSubModel(RandomProcessor(2))
self.processor3 = self.addSubModel(RandomProcessor(3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
def __init__(self, ta):
CoupledDEVS.__init__(self, "DualDepthProcessor")
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.processor1 = self.addSubModel(CoupledProcessor(ta, 1), 2)
self.processor2 = self.addSubModel(CoupledProcessor(ta, 2))
self.connectPorts(self.inport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Coupled")
self.generator = self.addSubModel(Generator())
self.processor1 = self.addSubModel(RandomProcessor(1))
self.processor2 = self.addSubModel(RandomProcessor(2))
self.processor3 = self.addSubModel(RandomProcessor(3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
def __init__(self, width):
CoupledDEVS.__init__(self, "Queue")
self.generator = self.addSubModel(Generator())
prev = self.generator
seeds = [i * 1000 for i in range(width)]
for i in range(width):
m = self.addSubModel(Processor("Processor%i" % i, seeds[i]))
self.connectPorts(prev.send_event1, m.recv_event1)
prev = m
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.models = []
# First model
self.models.append(self.addSubModel(Generator()))
# Second model
self.models.append(self.addSubModel(Consumer(0)))
# And connect them
self.connectPorts(self.models[0].outport, self.models[1].inport)
def __init__(self, t_gen_event1=1):
CoupledDEVS.__init__(self, "CoupledGenerator")
self.generator = self.addSubModel(
GeneratorNPP("Generator", t_gen_event1))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.connectPorts(self.inport, self.generator.inport)
self.connectPorts(self.generator.outport, self.outport)
def __init__(self, ta):
CoupledDEVS.__init__(self, "DualDepthProcessor")
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.processor1 = self.addSubModel(CoupledProcessor(ta, 1), 2)
self.processor2 = self.addSubModel(CoupledProcessor(ta, 2))
self.connectPorts(self.inport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.outport)
def __init__(self, iterations):
CoupledDEVS.__init__(self, "HugeOptimizableChain")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor0 = self.addSubModel(CoupledHeavyProcessor(0.77, 10, iterations))
self.processor1 = self.addSubModel(CoupledHeavyProcessor(0.66, 10, iterations))
self.processor2 = self.addSubModel(CoupledHeavyProcessor(0.30, 10, iterations))
self.connectPorts(self.generator.outport, self.processor0.inport)
self.connectPorts(self.processor0.outport, self.processor1.inport)
self.connectPorts(self.processor0.outport, self.processor2.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Mini")
self.listener_B = self.addInPort("listener_B")
self.output_B = self.addOutPort("output_B")
self.model_one = self.addSubModel(Proc("C"))
self.model_two = self.addSubModel(Proc("D"))
self.connectPorts(self.listener_B, self.model_one.inport)
self.connectPorts(self.listener_B, self.model_two.inport)
self.connectPorts(self.model_one.outport, self.output_B)
def __init__(self):
CoupledDEVS.__init__(self, "Boundary")
self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
self.processor1 = self.addSubModel(CoupledProcessor(0.60, 2), 2)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 4), 3)
self.processor3 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor1.outport, self.processor3.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Boundary")
self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
self.processor1 = self.addSubModel(CoupledProcessor(0.60, 2), 2)
self.processor2 = self.addSubModel(CoupledProcessor(0.30, 4), 3)
self.processor3 = self.addSubModel(CoupledProcessor(0.30, 3))
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor1.outport, self.processor3.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
def __init__(self, width):
CoupledDEVS.__init__(self, "HighInterconnect")
l = []
# Give each generator a different seed to start with, otherwise it wouldn't be random
seeds = [i * 1000 for i in range(width)]
for i in range(width):
l.append(self.addSubModel(Generator(seeds[i])))
for i in l:
for j in l:
if i != j:
self.connectPorts(i.send_event, j.recv_event)
def __init__(self):
CoupledDEVS.__init__(self, "MultipleInputs")
self.generator = self.addSubModel(Generator(1.0))
self.processors1 = []
for i in xrange(5):
self.processors1.append(self.addSubModel(Processor("1-" + str(i), 0.3)))
self.connectPorts(self.generator.outport, self.processors1[-1].inport)
self.processors2 = []
for i in xrange(2):
self.processors2.append(self.addSubModel(Processor("2-" + str(i), 0.3)))
for s in self.processors1:
self.connectPorts(s.outport, self.processors2[-1].inport)
def __init__(self, t_event1_P1):
CoupledDEVS.__init__(self, "CoupledProcessorMP")
self.inport = self.addInPort("inport")
p1 = self.addSubModel(Processor("Processor1", t_event1_P1))
p2 = self.addSubModel(Processor("Processor2", t_event1_P1))
p3 = self.addSubModel(Processor("Processor3", t_event1_P1))
p4 = self.addSubModel(Processor("Processor4", t_event1_P1))
self.connectPorts(self.inport, p1.inport)
self.connectPorts(self.inport, p3.inport)
self.connectPorts(p1.outport, p2.inport)
self.connectPorts(p3.outport, p4.inport)
def __init__(self, t_event1_P1, levels):
CoupledDEVS.__init__(self, "CoupledProcessor_" + str(levels))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.coupled = []
for i in range(levels):
self.coupled.append(self.addSubModel(Processor("Processor" + str(i), t_event1_P1)))
for i in range(levels-1):
self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport)
self.connectPorts(self.inport, self.coupled[0].inport)
self.connectPorts(self.coupled[-1].outport, self.outport)
def __init__(self, iterations):
CoupledDEVS.__init__(self, "HugeOptimizableChain")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processor0 = self.addSubModel(
CoupledHeavyProcessor(0.77, 10, iterations))
self.processor1 = self.addSubModel(
CoupledHeavyProcessor(0.66, 10, iterations))
self.processor2 = self.addSubModel(
CoupledHeavyProcessor(0.30, 10, iterations))
self.connectPorts(self.generator.outport, self.processor0.inport)
self.connectPorts(self.processor0.outport, self.processor1.inport)
self.connectPorts(self.processor0.outport, self.processor2.inport)
def __init__(self, t_event1_P1):
CoupledDEVS.__init__(self, "CoupledProcessorMP")
self.inport = self.addInPort("inport")
p1 = self.addSubModel(Processor("Processor1", t_event1_P1))
p2 = self.addSubModel(Processor("Processor2", t_event1_P1))
p3 = self.addSubModel(Processor("Processor3", t_event1_P1))
p4 = self.addSubModel(Processor("Processor4", t_event1_P1))
self.connectPorts(self.inport, p1.inport)
self.connectPorts(self.inport, p3.inport)
self.connectPorts(p1.outport, p2.inport)
self.connectPorts(p3.outport, p4.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Chain")
self.generator = self.addSubModel(CoupledGenerator(1.0), 0)
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.66, 3), 2)
self.processor3 = self.addSubModel(CoupledProcessor(0.66, 4), 1)
self.processor4 = self.addSubModel(CoupledProcessor(0.66, 5), 0)
self.processor5 = self.addSubModel(CoupledProcessor(0.30, 6), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
self.connectPorts(self.processor3.outport, self.processor4.inport)
self.connectPorts(self.processor4.outport, self.processor5.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Coupled")
self.inport1 = self.addInPort("inport1")
self.inport2 = self.addInPort("inport2")
self.outport = self.addOutPort("outport")
self.proc1 = self.addSubModel(ProcessorClassic1())
self.proc2 = self.addSubModel(ProcessorClassic1())
self.connectPorts(self.inport1, self.proc1.inport)
self.connectPorts(self.inport2, self.proc2.inport)
self.connectPorts(self.proc1.outport, self.outport)
self.connectPorts(self.proc2.outport, self.outport)
def __init__(self, num):
CoupledDEVS.__init__(self, "CoupledProcessor_" + str(num))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.coupled = []
levels = 4
for i in range(levels):
self.coupled.append(self.addSubModel(Processor("Processor" + str(i), 1.0)))
for i in range(levels-1):
self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport, trans1)
self.connectPorts(self.inport, self.coupled[0].inport)
self.connectPorts(self.coupled[-1].outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Coupled")
self.inport1 = self.addInPort("inport1")
self.inport2 = self.addInPort("inport2")
self.outport = self.addOutPort("outport")
self.proc1 = self.addSubModel(ProcessorClassic1())
self.proc2 = self.addSubModel(ProcessorClassic1())
self.connectPorts(self.inport1, self.proc1.inport)
self.connectPorts(self.inport2, self.proc2.inport)
self.connectPorts(self.proc1.outport, self.outport)
self.connectPorts(self.proc2.outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Chain")
self.generator = self.addSubModel(CoupledGenerator(1.0), 0)
self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
self.processor2 = self.addSubModel(CoupledProcessor(0.66, 3), 2)
self.processor3 = self.addSubModel(CoupledProcessor(0.66, 4), 1)
self.processor4 = self.addSubModel(CoupledProcessor(0.66, 5), 0)
self.processor5 = self.addSubModel(CoupledProcessor(0.30, 6), 2)
self.connectPorts(self.generator.outport, self.processor1.inport)
self.connectPorts(self.processor1.outport, self.processor2.inport)
self.connectPorts(self.processor2.outport, self.processor3.inport)
self.connectPorts(self.processor3.outport, self.processor4.inport)
self.connectPorts(self.processor4.outport, self.processor5.inport)
def __init__(self,
identifier,
market_orderbooks,
input_ports,
output_ports,
internal_connections,
external_input_connections,
external_output_connections,
regulator=None,
journal=None):
CoupledDEVS.__init__(self, identifier)
self.identifier = identifier
orderbooks = {
orderbook.identifier: self.addSubModel(orderbook)
for orderbook in market_orderbooks
}
regulator = self.addSubModel(regulator)
journal = self.addSubModel(journal)
# Make it accessible outside of our own scope
self.journal = journal
self.regulator = regulator
self.orderbooks = orderbooks
all_components = {
component.identifier: component
for component in [regulator, journal] + list(orderbooks.values())
}
# IOPorts initialization
for port_name in input_ports:
setattr(self, port_name, self.addInPort(port_name))
for port_name in output_ports:
setattr(self, port_name, self.addOutPort(port_name))
# External input connections
for left, right in external_input_connections:
component_port_from = getattr(self, left)
component_port_to = getattr(all_components[right[0]], right[1])
self.connectPorts(component_port_from, component_port_to)
# External output connections
for left, right in external_output_connections:
component_port_from = getattr(all_components[left[0]], left[1])
component_port_to = getattr(self, right)
self.connectPorts(component_port_from, component_port_to)
# Internal connections
for left, right in internal_connections:
component_port_from = getattr(all_components[left[0]], left[1])
component_port_to = getattr(all_components[right[0]], right[1])
self.connectPorts(component_port_from, component_port_to)
def __init__(self, t_event1_P1, levels, iterations, name = None):
if name == None:
name = "CoupledHeavyProcessor_" + str(levels)
CoupledDEVS.__init__(self, name)
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.coupled = []
for i in range(levels):
self.coupled.append(self.addSubModel(HeavyProcessor("Processor" + str(i), t_event1_P1, iterations)))
for i in range(levels-1):
self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport)
self.connectPorts(self.inport, self.coupled[0].inport)
self.connectPorts(self.coupled[-1].outport, self.outport)
def __init__(self, t_event1_P1, levels):
CoupledDEVS.__init__(self, "CoupledProcessor_" + str(levels))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
self.coupled = []
for i in range(levels):
self.coupled.append(
self.addSubModel(Processor("Processor" + str(i), t_event1_P1)))
for i in range(levels - 1):
self.connectPorts(self.coupled[i].outport,
self.coupled[i + 1].inport)
self.connectPorts(self.inport, self.coupled[0].inport)
self.connectPorts(self.coupled[-1].outport, self.outport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.model1 = self.addSubModel(GeneratorClassic())
self.model2 = self.addSubModel(ProcessorCoupledClassic())
self.model3 = self.addSubModel(ProcessorClassic2())
self.model4 = self.addSubModel(ProcessorClassic1())
self.model5 = self.addSubModel(ProcessorClassicO2())
self.connectPorts(self.model1.outport, self.model2.inport1)
self.connectPorts(self.model1.outport, self.model2.inport2)
self.connectPorts(self.model2.outport, self.model3.inport1)
self.connectPorts(self.model2.outport, self.model3.inport2)
self.connectPorts(self.model3.outport, self.model5.inport)
self.connectPorts(self.model2.outport, self.model4.inport)
self.connectPorts(self.model4.outport, self.model5.inport)
def __init__(self):
CoupledDEVS.__init__(self, "Root")
self.model1 = self.addSubModel(GeneratorClassic())
self.model2 = self.addSubModel(ProcessorCoupledClassic())
self.model3 = self.addSubModel(ProcessorClassic2())
self.model4 = self.addSubModel(ProcessorClassic1())
self.model5 = self.addSubModel(ProcessorClassicO2())
self.connectPorts(self.model1.outport, self.model2.inport1)
self.connectPorts(self.model1.outport, self.model2.inport2)
self.connectPorts(self.model2.outport, self.model3.inport1)
self.connectPorts(self.model2.outport, self.model3.inport2)
self.connectPorts(self.model3.outport, self.model5.inport)
self.connectPorts(self.model2.outport, self.model4.inport)
self.connectPorts(self.model4.outport, self.model5.inport)
def __init__(self, nodes, totalAtomics, iterations):
CoupledDEVS.__init__(self, "AutoDistChain")
self.generator = self.addSubModel(CoupledGenerator(1.0))
self.processors = []
have = 0
ta = 0.66
for i in range(nodes):
shouldhave = (float(i+1) / nodes) * totalAtomics
num = int(shouldhave - have)
have += num
if i == 0:
self.processors.append(self.addSubModel(CoupledHeavyProcessor(ta, num, iterations, "HeavyProcessor_" + str(i))))
else:
self.processors.append(self.addSubModel(CoupledHeavyProcessor(ta, num, iterations, "HeavyProcessor_" + str(i)), i))
self.connectPorts(self.generator.outport, self.processors[0].inport)
for i in range(len(self.processors)-1):
self.connectPorts(self.processors[i].outport, self.processors[i+1].inport)
def __init__(self, it, namecounter):
CoupledDEVS.__init__(self, "CoupledProcessor_%s_%s" % (it, namecounter))
self.inport = self.addInPort("inport")
self.outport = self.addOutPort("outport")
if it != 0:
self.subproc = self.addSubModel(ClassicCoupledProcessor(it-1, 0))
else:
self.subproc = self.addSubModel(ClassicProcessor(0))
self.subproc2 = self.addSubModel(ClassicProcessor(1))
if it != 0:
self.subproc3 = self.addSubModel(ClassicCoupledProcessor(it-1, 2))
else:
self.subproc3 = self.addSubModel(ClassicProcessor(2))
self.connectPorts(self.inport, self.subproc.inport)
self.connectPorts(self.subproc.outport, self.subproc2.inport)
self.connectPorts(self.subproc2.outport, self.subproc3.inport)
self.connectPorts(self.subproc3.outport, self.outport)
def __init__(self, x_max, y_max):
CoupledDEVS.__init__(self, "FireSpread")
self.cells = []
try:
from mpi4py import MPI
nodes = MPI.COMM_WORLD.Get_size()
except ImportError:
nodes = 1
node = 0
totalCount = x_max * y_max
counter = 0
for x in range(x_max):
row = []
for y in range(y_max):
if nodes == 1:
node = 0
elif x <= x_max/2 and y < y_max/2:
node = 0
elif x <= x_max/2 and y > y_max/2:
node = 1
elif x > x_max/2 and y < y_max/2:
node = 2
elif x > x_max/2 and y > y_max/2:
node = 3
row.append(self.addSubModel(Cell(x, y, x_max, y_max), node))
self.cells.append(row)
counter += 1
# Everything is now constructed, so connect the ports now
self.generator = self.addSubModel(Generator(RADIUS))
self.putGenerator(x_max/2, y_max/2)
for x in range(x_max):
for y in range(y_max):
if x != 0:
self.connectPorts(self.cells[x][y].outport, self.cells[x-1][y].inports[2])
if y != y_max - 1:
self.connectPorts(self.cells[x][y].outport, self.cells[x][y+1].inports[1])
if x != x_max - 1:
self.connectPorts(self.cells[x][y].outport, self.cells[x+1][y].inports[3])
if y != 0:
self.connectPorts(self.cells[x][y].outport, self.cells[x][y-1].inports[0])
