def __init__(self, physical_layer, ambient_noise, channel_event, position_query, sir_thresh, on_success, name="a_transducer"): # A resource with large capacity, because we don't want incoming messages to queue, # We want them to interfere. Sim.Resource.__init__(self, name=name, capacity=1000) self.physical_layer = physical_layer self.logger = physical_layer.logger.getChild( "{0}".format(self.__class__.__name__)) # Interference is initialized as ambient noise self.interference = ambient_noise # Setup our event listener self.channel_event = channel_event self.listener = AcousticEventListener(self) Sim.activate(self.listener, self.listener.listen( self.channel_event, position_query)) # Function to call when we've received a packet self.on_success = on_success # SIR threshold self.SIR_thresh = sir_thresh # Controls the half-duplex behavior self.transmitting = False # Takes statistics about the collisions self.collision = False self.collisions = []
def generate(self, number, interval): rv = Random(self.SEED) for i in range(number): c = Customer(name="Customer%02d" % (i, )) Simulation.activate(c, c.visit(timeInBank=12.0)) t = rv.expovariate(1.0 / interval) yield Simulation.hold, self, t
def sendRequest(self, task, replicaToServe): delay = constants.NW_LATENCY_BASE + \ random.normalvariate(constants.NW_LATENCY_MU, constants.NW_LATENCY_SIGMA) # record send time self.sendtime[replicaToServe] = Simulation.now() # Immediately send out request messageDeliveryProcess = DeliverMessageWithDelay() Simulation.activate(messageDeliveryProcess, messageDeliveryProcess.run(task, delay, replicaToServe), at=Simulation.now()) responseHandler = ResponseHandler() Simulation.activate(responseHandler, responseHandler.run(self, task, replicaToServe), at=Simulation.now()) # Book-keeping for metrics self.pendingRequestsMap[replicaToServe] += 1 self.pendingXserviceMap[replicaToServe] = \ (1 + self.pendingRequestsMap[replicaToServe]) \ * replicaToServe.serviceTime self.pendingRequestsMonitor.observe( "%s %s" % (replicaToServe.id, self.pendingRequestsMap[replicaToServe])) self.taskSentTimeTracker[task] = Simulation.now()
def sendRequest(self, task, replicaToServe): delay = constants.NW_LATENCY_BASE + \ random.normalvariate(constants.NW_LATENCY_MU, constants.NW_LATENCY_SIGMA) # Immediately send out request messageDeliveryProcess = DeliverMessageWithDelay() Simulation.activate(messageDeliveryProcess, messageDeliveryProcess.run(task, delay, replicaToServe), at=Simulation.now()) responseHandler = ResponseHandler() Simulation.activate(responseHandler, responseHandler.run(self, task, replicaToServe), at=Simulation.now()) # Book-keeping for metrics self.pendingRequestsMap[replicaToServe] += 1 self.pendingXserviceMap[replicaToServe] = \ (1 + self.pendingRequestsMap[replicaToServe]) \ * replicaToServe.serviceTime self.pendingRequestsMonitor.observe( "%s %s" % (replicaToServe.id, self.pendingRequestsMap[replicaToServe])) self.taskSentTimeTracker[task] = Simulation.now()
def schedule_arrival(self, transducer, params, pos): """ :param transducer: :param params: :param pos: """ distance_to = distance(pos, params["pos"]()) if distance_to > 0.01: # I should not receive my own transmissions receive_power = params["power"] - \ attenuation_db(params["frequency"], distance_to) # Speed of sound in water = 1482.0 m/s travel_time = distance_to / transducer.physical_layer.medium_speed packet = params['packet'] if DEBUG: transducer.logger.debug("{type} from {source} to {dest} will take {t} to get to me {d}m away".format( type=packet['type'], source=packet['source'], dest=packet['dest'], t=travel_time, d=int(distance_to)) ) yield Sim.hold, self, travel_time new_incoming_packet = IncomingPacket( db2linear(receive_power), params["packet"], transducer.physical_layer) Sim.activate( new_incoming_packet, new_incoming_packet.receive(params["duration"]))
def __init__(self, id, interval): self.rate = 0 self.id = id self.interval = interval self.count = 0 Simulation.Process.__init__(self, name=self.id) Simulation.activate(self, self.run(), at=Simulation.now())
def run(self, node_no): while (1): print("hello i am slave node ", node_no) if len(G.slave_nodes_attr[node_no].node_queries_queue ) == 0: #if queue is empty, sleep yield Sim.passivate, self print("reactivated", node_no) yield Sim.hold, self, 1 #0.5*abs(constant.RND.expovariate(constant.QUERY_RATE)) print("query_created for req no", G.slave_nodes_attr[node_no].node_queries_queue[0][0]) time_of_use = self.sim.now() query_obj = query() #create query object to process the query Sim.activate( query_obj, query_obj.run( G.slave_nodes_attr[node_no].node_queries_queue[0], node_no)) if self.interrupted(): yield Sim.hold, self, 1 # abs(self.interruptLeft - time_of_use) #check for break down G.slave_nodes_attr[node_no].node_queries_queue.pop( 0) #remove request after processed
def testBackPressureLoopTwoServers(self): Simulation.initialize() s1 = server.Server(1, resourceCapacity=1, serviceTime=4, serviceTimeModel="constant") s2 = server.Server(2, resourceCapacity=1, serviceTime=4, serviceTimeModel="constant") c1 = client.Client(id_="Client1", serverList=[s1, s2], replicaSelectionStrategy="primary", accessPattern="uniform", replicationFactor=2, backpressure=True, shadowReadRatio=0.0, rateInterval=20, cubicC=0.000004, cubicSmax=10, cubicBeta=0.2, hysterisisFactor=2, demandWeight=1.0) observer = Observer([s1, s2], c1) Simulation.activate(observer, observer.testBackPressureLoopTwoServers(), at=0.1) Simulation.simulate(until=100)
def run_experiment(args, log): data_directory = "../%s/%s" % (args.data_folder, args.topology) topo = create_topology(args, data_directory) # topo.draw() ctrl = create_ctrl(args, topo) ezsegway = EzSegway(ctrl, topo) global_vars.ctrl = ctrl global_vars.switches, global_vars.switch_ids = create_sw(args, topo, ctrl) Simulation.activate(global_vars.ctrl, global_vars.ctrl.run(), at=0.0) Simulation.activate(ezsegway, ezsegway.run(), at=0.0) flow_folder = utils.get_flow_folder(data_directory, args.topology_type, args.generating_method, args.number_of_flows, args.failure_rate) update_time = run_one_test( args, log, ezsegway, flow_folder + "/flows_%d.intra" % args.test_number) with open("../results.dat", "a") as f: res = [ args.method, args.topology, args.generating_method, args.failure_rate, args.number_of_flows, args.test_number, update_time ] res = [str(x) for x in res] f.write(','.join(res) + "\n")
def receive(self, source, pre_spike_time): #print(simpy.now(), ":", str(self), "at", self.membrane_potential, "receive", self.dendrites[source]) #increse membrane potential membrane_potential_increment = self.dendrites[source] #self.membrane_potential += membrane_potential_increment #insert the source into the left window left_window_item = [source, pre_spike_time, simpy.now()] self.left_window.append(left_window_item) #check to weaken the dendrite by each action in the right window for post_spike_time in self.right_window: self.adjust_weight(source, pre_spike_time - post_spike_time) #check if it can fire if self.membrane_potential >= self.threshold: if simpy.now() > self.last_firing_time: self.last_firing_time = simpy.now() event = Event(name = str(self) + " fire") simpy.activate(event, event.fire(self), delay = 0.0) #remove the source from the left window when it's over, and decrease the membrane potential event = Event(name = str(self) + "remove an item from left window") simpy.activate(event, event.remove_from_left_window(self, left_window_item, membrane_potential_increment), delay = self.left_window_width)
def test_updating_trajectory(self): """Creates a vehicle, starts the sim with it travelling at a fixed velocity, then changes the trajectory 11 seconds after the start. When the trajectory is changed, the vehicle is straddling two track segments.""" v0 = vehicle.BaseVehicle(0, self.ts0, 50, 5) # fixed velocity, 5 m/s # stop at 50 meters on ts2 spline = CubicSpline( [2, 6.2324427610773778, 20.693227678868798, 46.258768272424305, 46.67126664464751, 49.999999999978492], # pos [5, 5.8065992674127145, 9.581117951456692, 5.3923182554918929, 4.9953989633679301, -9.5825569701446511e-12], # vel [0, 2.0082321422244926, 2.0082321422244926, -4.9976989522066617, -4.9976989522066617, -1.8332002582610585e-12], # accel [2.5, 0, -2.5, 0, 2.5], # jerk [11, 11.803292856889797, 13.682815948210798, 16.48518838598326, 16.564608794439177, 18.56368837532111]) # time spline_msg = api.Spline() spline.fill_spline_msg(spline_msg) controller = MockController() controller.add_cmd(11, v0.process_spline_msg, spline_msg) Sim.activate(controller, controller.run()) Sim.activate(v0, v0.ctrl_loop()) Sim.simulate(until=20) self.assertAlmostEqual(v0.pos, 50, self.PLACES) self.assertTrue(v0.loc is self.ts2) self.assertAlmostEqual(v0.vel, 0, self.PLACES) self.assertAlmostEqual(v0.accel, 0, self.PLACES) self.assertAlmostEqual(v0.tail_pos, 45, self.PLACES) self.assertTrue(v0.tail_loc is self.ts2) self.assertTrue(len(self.ts0.vehicles) == 0) self.assertTrue(len(self.ts1.vehicles) == 0) self.assertTrue(len(self.ts2.vehicles) == 1)
def update(self, now): #print(self.membrane_potential) if self.type == 'current': self.value_record.append(self.value) self.value *= self.output_current_decay if self.refact == 'yes': self.spikes_record.append(self.membrane_potential) return self.membrane_potential -= (self.membrane_potential - self.reset_potential)*0.1 #leak input = 0.0 for source in self.dendrites.keys(): if source.type == 'current': input += source.value elif source.type == 'voltage': pass # Voltage type input, add code here self.membrane_potential += input * 0.1 if self.membrane_potential < self.reset_potential: self.membrane_potential = self.reset_potential record = self.membrane_potential if self.membrane_potential >= self.threshold: if simpy.now() > self.last_firing_time: self.last_firing_time = simpy.now() event = Event(name = str(self) + " fire") simpy.activate(event, event.fire(self), delay = 0.0) record = self.spike_potential self.spikes_record.append(record)
def transmit_packet(self, packet): if not self.is_idle(): # The MAC protocol is the one that should check this before # transmitting self.logger.warn( "I should not do this... the channel is not idle!" "Trying to send {typ} to {dest}" "Currently have {q}".format( typ=packet['type'], dest=packet['dest'], q=self.transducer.activeQ )) if self.variable_power: tx_range = self.level2distance[str(packet["level"])] power = distance2intensity( self.bandwidth, self.freq, tx_range, self.SNR_threshold) else: power = self.transmit_power if power > self.max_output_power_used: self.max_output_power_used = power if power > self.max_output_power: power = self.max_output_power new_transmission = OutgoingPacket(self) Sim.activate( new_transmission, new_transmission.transmit(packet, power))
def generate(self, number, interval, resources, monitors, times, exitResource, exitMonitor, entryResource, entryMonitor, preScreenedPercentage): """ @param number: number of entitites to generate (integer) @param interval: mean (in minutes) of times inter arrival @param resources: array of resources (servers) @param monitors: array of monitors to collect statistics @param times: avg. service time depending on the resource """ for i in range(number): customerName = "customer%d"%i c = Customer.Customer(name=customerName, resources=resources, monitors=monitors, times=times, exitResource=exitResource, exitMonitor=exitMonitor, entryResource=entryResource, entryMonitor=entryMonitor, preScreenedPercentage=preScreenedPercentage ) simpy.activate(c,c.visit()) t = random.expovariate(1.0/interval) yield simpy.hold, self, t
def runExperiment(): Simulation.initialize() c = client.Client(1) s = server.Server(1) w = workload.Workload(c, s) Simulation.activate(w, w.run(), at=Simulation.now()) Simulation.simulate(until=50.0)
def simTransmission(self, packet): if not self.simPacketLoss(): packet.rxTime = packet.txTime + self.simDelay() receivePacket = ReceivePacket(packet=packet) simpy.activate(receivePacket, receivePacket.run()) link = packet.txHost.transmitter.findLink(packet.rxHost) link.session.transmittedPackets.append(packet)
def simTransmission(self, packet): if not self.simPacketLoss(): delay = self.simDelay() print "%7.4f Packet delay-> %1d" % (delay, packet.seqNumber) packet.rxTime = packet.txTime + delay #packet.rxTime = packet.txTime + self.simDelay() receivePacket = ReceivePacket(packet=packet) simpy.activate(receivePacket, receivePacket.run()) self.link.transmittedPackets.append(packet)
def test_accumulate_in_time(): """Tests accumulation over simulation time""" s=Simulation() s.initialize() m3 = Monitor(name = 'third',sim=s) T3 = Thing(name = 'Job', M = m3,sim=s) assert m3.startTime == 0, 'Accumulate startTime wrong' s.activate(T3, T3.execute(),0.0) s.simulate(until = 30.0) assert m3.startTime == 0, 'Accumulate startTime wrong'
def test_accumulate_in_time(): """Tests accumulation over simulation time""" s = Simulation() s.initialize() m3 = Monitor(name='third', sim=s) T3 = Thing(name='Job', M=m3, sim=s) assert m3.startTime == 0, 'Accumulate startTime wrong' s.activate(T3, T3.execute(), 0.0) s.simulate(until=30.0) assert m3.startTime == 0, 'Accumulate startTime wrong'
def listen(self, channel_event, position_query): """ :param channel_event: :param position_query: """ while True: yield Sim.waitevent, self, channel_event params = channel_event.signalparam sched = ArrivalScheduler(name="ArrivalScheduler" + self.name[-1]) Sim.activate(sched, sched.schedule_arrival( self.transducer, params, position_query()))
def new_agent(self): x = gauss(self.mean_x, self.sd_x) y = gauss(self.mean_y, self.sd_y) speak = expovariate(1.0/self.mean_speak) learn = expovariate(1.0/self.mean_learn) innovation = expovariate(1.0/self.mean_innovation) agent = Agent(x, y, speak, learn, innovate) self.agents.append(agent) Sim.activate(agent, agent.go()) return agent
def test_collision(self): # TODO: Test post collision state, once decided what to do upon collisions... """Simple collision test. Two vehicles on the same track segment, the rear one with an initial velocity, the lead one stopped. Simulation halts before the 'rear' vehicle leaves the segment.""" v0 = vehicle.BaseVehicle(0, self.ts0, 10, 5) # fixed speed, 5 m/s v1 = vehicle.BaseVehicle(1, self.ts0, 50, 0) Sim.activate(v0, v0.ctrl_loop()) Sim.activate(v1, v1.ctrl_loop()) Sim.simulate(until=16) self.assertAlmostEqual(v0.pos, 90, self.PLACES)
def model(counterseed=3939393): global counter, counterRV, waitMonitor counter = Simulation.Resource(name="Clerk", capacity=1) counterRV = Random(counterseed) waitMonitor = Simulation.Monitor() Simulation.initialize() sourceseed = 1133 source = Source(seed=sourceseed) Simulation.activate(source, source.generate(100, 10.0)) ob = Observer() Simulation.activate(ob, ob.observe()) Simulation.simulate(until=2000.0)
def test_observe_no_time(): """Observe with time being picked up from now()""" s = Simulation() s.initialize() m = Monitor(name = 'No time',sim=s) t = Thing(m,sim=s) s.activate(t, t.execute(),0.0) s.simulate(until = 20.0) assert m.yseries() == [0, 10, 5],'yseries wrong:%s' % (m.yseries(),) assert m.tseries() == [0, 10, 20],'tseries wrong:%s' % (m.tseries(),) assert m.total() == 15, 'total wrong:%s'%m.total() assert m.timeAverage(10.0) == 5.0, 'time average is wrong: %s'%m.timeAverage(10.0)
def test_get_level(): """Test of "yield get,self,level" """ s = Simulation() s.initialize() levl = Level() # wrong sim r = GetLeveltest(sim=s) s.activate(r, r.run(level=levl)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_observe_no_time(): """Observe with time being picked up from now()""" s = Simulation() s.initialize() m = Monitor(name='No time', sim=s) t = Thing(m, sim=s) s.activate(t, t.execute(), 0.0) s.simulate(until=20.0) assert m.yseries() == (0, 10, 5), 'yseries wrong:%s' % (m.yseries(), ) assert m.tseries() == (0, 10, 20), 'tseries wrong:%s' % (m.tseries(), ) assert m.total() == 15, 'total wrong:%s' % m.total() assert m.timeAverage( 10.0) == 5.0, 'time average is wrong: %s' % m.timeAverage(10.0)
def test_queueevent(): """Test of "yield queueevent,self,evt" """ s = Simulation() s.initialize() evt = SimEvent() ## wrong sim w = Queueeventtest(sim=s) s.activate(w, w.run(event=evt)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_request(): """Test of "yield request,self,res" """ s = Simulation() s.initialize() res = Resource( ) # wrong sim r = Requesttest(sim=s) s.activate(r,r.run(res = res)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_put_store(): """Test of "yield put,self,store" """ s = Simulation() s.initialize() store = Store() # wrong sim r = PutStoretest(sim=s) s.activate(r, r.run(store=store)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_get_level(): """Test of "yield get,self,level" """ s = Simulation() s.initialize() levl = Level( ) # wrong sim r = GetLeveltest(sim=s) s.activate(r,r.run(level = levl)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_put_store(): """Test of "yield put,self,store" """ s = Simulation() s.initialize() store = Store( ) # wrong sim r = PutStoretest(sim=s) s.activate(r,r.run(store = store)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_queueevent(): """Test of "yield queueevent,self,evt" """ s = Simulation() s.initialize() evt = SimEvent() ## wrong sim w = Queueeventtest(sim = s) s.activate(w,w.run(event = evt)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def test_request(): """Test of "yield request,self,res" """ s = Simulation() s.initialize() res = Resource() # wrong sim r = Requesttest(sim=s) s.activate(r, r.run(res=res)) try: s.simulate(until=1) except FatalSimerror: pass else: assert False, "expected FatalSimerror"
def create_sw(args, topo, ctrl): switches = [] for node in topo.graph.nodes(): if args.method == constants.CENTRALIZED_METHOD: sw = centralized_switch.CentralizedSwitch( node, ctrl, sorted(topo.graph.neighbors(node))) elif args.method == constants.P2P_METHOD: sw = ez_segway_switch.EzSegwaySwitch( node, ctrl, sorted(topo.graph.neighbors(node))) Simulation.activate(sw, sw.run(), at=0.0) switches.append(sw) global_vars.switch_ids = sorted(topo.graph.nodes()) return sorted(switches), sorted(topo.graph.nodes())
def sendRequest(self, request, toServer): delay = constants.NW_LATENCY_BASE + \ random.normalvariate(constants.NW_LATENCY_MU, constants.NW_LATENCY_SIGMA) # Send out the request requestDeliveryProcess = DeliverRequest() Simulation.activate(requestDeliveryProcess, requestDeliveryProcess.run(request, toServer, delay), at=Simulation.now()) responseHandler = ResponseHandler() Simulation.activate(responseHandler, responseHandler.run(request), at=Simulation.now())
def new_agent(self): x = gauss(self.mean_x, self.sd_x) y = gauss(self.mean_y, self.sd_y) speak = expovariate(1.0/self.mean_speak) learn = expovariate(1.0/self.mean_learn) innovation = expovariate(1.0/self.mean_innovation) location = gauss(self.mean_loc, self.loc_sd) radius = expovariate(1.0/self.mean_talk_radius) agent = LangRelativeAgent(x, y, speak, learn, innovation, location, radius) self.agents.append(agent) Sim.activate(agent, agent.go()) return agent
def run_simulation( t, steps, runs ): for r in range( runs ): sim = Simulation() sim.initialize() bank = Bank( monitored=True, monitorType=Tally, sim=sim ) bank.setServicetime( t ) src = CustomerGenerator( sim=sim ) sim.activate( src, src.produce( bank ) ) sim.startCollection( when=steps//2 ) sim.simulate( until=steps ) print t, bank.waitMon.mean()
def model(): print "Initializing..." Sim.initialize() print "Random seed: %s" % (Parameters.randSeed,) random.seed(Parameters.randSeed) print "Verbose:", Parameters.verbose Parameters.languages = [ Language(Parameters.langStatuses[i], "Language %s" % (i,)) for i in range(Parameters.numLanguages) ] Parameters.numSpeakers = 0 speakers = [] langIdx = 0 for population in Parameters.initialDistribution: for i in range(population): speakers.append( Speaker( Parameters.languages[langIdx], gauss(Parameters.position_distribution[langIdx][0], Parameters.position_distribution[langIdx][1]), gauss(Parameters.position_distribution[langIdx][2], Parameters.position_distribution[langIdx][3]), "Speaker %s" % (Parameters.numSpeakers,), ) ) Parameters.numSpeakers += 1 langIdx += 1 for s in speakers: s.set_affecting_speakers_list(speakers) for s in speakers: Sim.activate(s, s.go()) timer = Timer() Sim.activate(timer, timer.tracktime(resolution=0.10)) print "Speakers: %s" % (Parameters.numSpeakers,) print "Initial population distribution:" for l in range(len(Parameters.languages)): print "\t%s: %s speakers" % (Parameters.languages[l], Parameters.initialDistribution[l]) print print "Simulating..." Sim.simulate(until=Parameters.simLength) print "Simulation Complete at t=%s" % Sim.now() return speakers
def initialize(): print 'Initializing...' Sim.initialize() print 'Random seed: ' + repr(params['random seed']) random.seed(params['random seed']) pop0 = LinePopulation( 500.0, 500.0, params['initial x std dev'], params['initial y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], 500.0, params['pop0 loc sd'], params['mean talk radius'] ) for i in range(params['num agents']): pop0.new_agent() segregator = Segregator() Sim.activate( segregator, segregator.go() )
def main(): print 'Initializing...' Sim.initialize() white = LinePopulation( params['white x mean'], params['white y mean'], params['white x std dev'], params['white y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['white mean loc'], params['white loc sd'], params['white talk radius'], 'white' ) seasoned = LinePopulation( 0.0, 0.0, 0.0, 0.0, params['mean speak'], params['mean learn'], params['mean innovation'], params['seasoned mean loc'], params['seasoned loc sd'], params['seasoned talk radius'], 'seasoned' ) bozal0 = LinePopulation( params['bozal0 x mean'], params['bozal0 y mean'], params['bozal0 x std dev'], params['bozal0 y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['bozal mean loc'], params['bozal loc sd'], params['bozal talk radius'], 'bozal 0') bozal1 = LinePopulation( params['bozal1 x mean'], params['bozal1 y mean'], params['bozal1 x std dev'], params['bozal1 y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['bozal mean loc'], params['bozal loc sd'], params['bozal talk radius'], 'bozal 1' ) for i in range(params['num white']): white.new_agent() for i in range(params['num slaves']): if i%2 == 0: bozal0.new_agent() else: bozal1.new_agent() adjuster = PopAdjuster( white, seasoned, bozal0, bozal1, params['update period'], params['pop schedule'], params['white pop targets'], params['slave pop targets'], params['proportion seasoned'] ) Sim.activate( adjuster, adjuster.go() ) number = math.ceil(params['proportion seasoned']*white.num_agents()) adjuster.get_seasoned( number, white, bozal0, bozal1, seasoned ) plotter = Plotter('gradual', params['plot period'], params['stop time'], params) Sim.activate( plotter, plotter.go() ) print 'Simulating...' Sim.simulate(until=params['stop time']) print 'Simulation Complete at t=%s' % Sim.now() plotter.cleanup()
def test_one_vehicle_loop_sim(self): """A single vehicle, running around the loop at a constant 5 m/s. Makes almost two complete loops, stopping 6 meters before it's starting position.""" v0 = vehicle.BaseVehicle(0, self.ts0, 50, 5) Sim.activate(v0, v0.ctrl_loop()) Sim.simulate(until=81.4) self.assertAlmostEqual(v0.pos, 1, self.PLACES) self.assertAlmostEqual(v0.tail_pos, 21, self.PLACES) self.assertTrue(v0.loc is self.ts0) self.assertTrue(v0.tail_loc is self.ts3) self.assertTrue(self.ts0.vehicles[0] is v0) self.assertEquals(len(self.ts1.vehicles), 0) self.assertEquals(len(self.ts2.vehicles), 0) self.assertTrue(self.ts3.vehicles[0] is v0)
def main(): print 'Initializing...' Sim.initialize() Agent.lang_tolerance = params['lang tolerance'] white = LangRelPop( params['white x mean'], params['white y mean'], params['white x std dev'], params['white y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['white mean loc'], params['white loc sd'], params['white talk radius'], 'white' ) seasoned = LangRelPop( params['seasoned x mean'], params['seasoned y mean'], params['seasoned x std dev'], params['seasoned y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['seasoned mean loc'], params['seasoned loc sd'], params['seasoned talk radius'], 'seasoned' ) bozal0 = LangRelPop( params['bozal0 x mean'], params['bozal0 y mean'], params['bozal0 x std dev'], params['bozal0 y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['bozal mean loc'], params['bozal loc sd'], params['bozal talk radius'], 'bozal 0') bozal1 = LangRelPop( params['bozal1 x mean'], params['bozal1 y mean'], params['bozal1 x std dev'], params['bozal1 y std dev'], params['mean speak'], params['mean learn'], params['mean innovation'], params['bozal mean loc'], params['bozal loc sd'], params['bozal talk radius'], 'bozal 1' ) for i in range(params['num white']): white.new_agent() for i in range(params['num seasoned']): seasoned.new_agent() for i in range(params['num bozal']): if i%2 == 0: bozal0.new_agent() else: bozal1.new_agent() plotter = Plotter('centripetal by lang', params['plot period'], params['stop time'], params) Sim.activate( plotter, plotter.go() ) print 'Simulating...' Sim.simulate(until=params['stop time']) print 'Simulation Complete at t=%s' % Sim.now() plotter.cleanup()
def fire(self): #reset membrane potential self.membrane_potential = self.reset_potential if self.type == 'current': self.value = self.output_current_peak self.refact = 'yes' event = Event(name = 'reactivate') simpy.activate(event, event.reactivate(self), delay = self.refactory_period, prior=True) #print(simpy.now(), ":", str(self), "fire") self.spikes_number += 1 #self.spikes_record.append(simpy.now()) current_time = simpy.now() #strengthen each source in current left window for source in self.left_window: self.adjust_weight(source[0], source[1] - current_time) #open a new right window self.right_window.append(current_time) #send action potential to each axon for target in self.axons.keys(): event = Event(name = str(target)+" receive from "+str(self)) simpy.activate(event, event.receive(target, self, current_time), delay = self.axons[target], prior = True) #close the right window when it's over event = Event(name = str(self) + " close right window") simpy.activate(event, event.close_a_right_window(self, current_time), delay = self.right_window_width)
def main(): Sim.initialize() master_node_sim = master_node() # creates 4 objects of class node (4 is the number of slave nodes) for slave_node_index in range(constant.NO_SLAVE_NODES): slave_node_attr = nodes() slave_node_attr.slave_node_id = slave_node() slave_node_attr.processor_id = processor() slave_node_attr.disk_id = disk() slave_node_attr.sensor_id = sensor() G.slave_nodes_attr.append(slave_node_attr) Sim.activate(slave_node_attr.slave_node_id, slave_node_attr.slave_node_id.run(slave_node_index)) Sim.activate(slave_node_attr.processor_id, slave_node_attr.processor_id.run(slave_node_index)) Sim.activate(slave_node_attr.disk_id, slave_node_attr.disk_id.run(slave_node_index)) Sim.activate(slave_node_attr.sensor_id, slave_node_attr.sensor_id.run(slave_node_index)) if slave_node_index == constant.NO_SLAVE_NODES - 1: print("slave nodes done, activating master..") Sim.activate(master_node_sim, master_node_sim.run()) Sim.simulate(until=500)
def run(self): while 1: c = Customer() Simulation.activate(c, c.checkout()) arrival = random.expovariate(float(AVGCUST)/CLOSING) yield hold, self, arrival
def __init__(self, id_, serverList, replicaSelectionStrategy, accessPattern, replicationFactor, backpressure, shadowReadRatio, rateInterval, cubicC, cubicSmax, cubicBeta, hysterisisFactor, demandWeight, costExponent, concurrencyWeight): self.id = id_ self.serverList = serverList self.accessPattern = accessPattern self.replicationFactor = replicationFactor self.REPLICA_SELECTION_STRATEGY = replicaSelectionStrategy self.pendingRequestsMonitor = \ Simulation.Monitor(name="PendingRequests") self.latencyTrackerMonitor = Simulation.Monitor(name="ResponseHandler") self.rateMonitor = Simulation.Monitor(name="AlphaMonitor") self.receiveRateMonitor = Simulation.Monitor(name="ReceiveRateMonitor") self.tokenMonitor = Simulation.Monitor(name="TokenMonitor") self.edScoreMonitor = Simulation.Monitor(name="edScoreMonitor") self.backpressure = backpressure # True/Flase self.shadowReadRatio = shadowReadRatio self.demandWeight = demandWeight self.costExponent = costExponent self.concurrencyWeight = concurrencyWeight # Book-keeping and metrics to be recorded follow... # Number of outstanding requests at the client self.pendingRequestsMap = {node: 0 for node in serverList} # Number of outstanding requests times oracle-service time of replica self.pendingXserviceMap = {node: 0 for node in serverList} # Last-received response time of server self.responseTimesMap = {node: 0 for node in serverList} # Used to track response time from the perspective of the client self.taskSentTimeTracker = {} self.taskArrivalTimeTracker = {} self.taskBatchCounter = {} # Record waiting and service times as relayed by the server self.expectedDelayMap = {node: {} for node in serverList} self.lastSeen = {node: 0 for node in serverList} # Round robin parameters self.rrIndex = {node: 0 for node in serverList} # Rate limiters per replica self.rateLimiters = { node: RateLimiter("RL-%s" % node.id, self, 10, rateInterval) for node in serverList } self.lastRateDecrease = {node: 0 for node in serverList} self.valueOfLastDecrease = {node: 10 for node in serverList} self.receiveRate = { node: ReceiveRate("RL-%s" % node.id, rateInterval) for node in serverList } self.lastRateIncrease = {node: 0 for node in serverList} self.rateInterval = rateInterval # Parameters for congestion control self.cubicC = cubicC self.cubicSmax = cubicSmax self.cubicBeta = cubicBeta self.hysterisisFactor = hysterisisFactor # Parameters for Refresh selection self.sendtime = {node: 0.00000000 for node in serverList} # Backpressure related initialization if (backpressure is True): self.backpressureSchedulers = \ {node: BackpressureScheduler("BP-%s" % node.id, self) for node in serverList} for node in serverList: Simulation.activate(self.backpressureSchedulers[node], self.backpressureSchedulers[node].run(), at=Simulation.now()) # ds-metrics if (replicaSelectionStrategy == "ds"): self.latencyEdma = { node: ExponentiallyDecayingSample(100, 0.75, self.clock) for node in serverList } self.dsScores = {node: 0 for node in serverList} for node, rateLimiter in self.rateLimiters.items(): ds = DynamicSnitch(self, 100) Simulation.activate(ds, ds.run(), at=Simulation.now())
def testRateLimiter3(self): Simulation.initialize() observer = Observer() Simulation.activate(observer, observer.test3(), at=0.1) Simulation.simulate(until=200)
NoInService = 0 Busy = 0 JobRate = lam JobMax = 10000 JobTRACING = 0 JobGenTRACING = 0 # Model/Experiment ------------------------------ seed(111333) s = Simulation() BM = Monitor(sim=s) MT = Monitor(sim=s) s.initialize() jbg = JobGen(sim=s) s.activate(jbg, jbg.execute(1.0, JobMax, mu), 0.0) s.simulate(until=20000.0) # Analysis/output ------------------------- print 'bcc' print "time at the end =", s.now() print "now=", s.now(), " startTime ", BM.startTime print "No Rejected = %d, ratio= %s" % (NoRejected, (1.0*NoRejected)/JobMax) print "Busy proportion (%6s) = %8.6f" % (dist, BM.timeAverage(s.now()), ) print "Erlang pc (th) = %8.6f" % (erlangB(rho, c)[c], )
Sim.initialize() SANglobal.F.nodecomplete = [] for i in range(len(SANglobal.F.nodes())): eventname = 'Complete%1d' % i SANglobal.F.nodecomplete.append(Sim.SimEvent(eventname)) SANglobal.F.nodecomplete activitynode = [] for i in range(len(SANglobal.F.nodes())): activityname = 'Activity%1d' % i activitynode.append(ActivityProcess(activityname)) for i in range(len(SANglobal.F.nodes())): if i <> SANglobal.inTo: prenodes = SANglobal.F.predecessors(i) preevents = [SANglobal.F.nodecomplete[j] for j in prenodes] Sim.activate(activitynode[i], activitynode[i].waitup(i, preevents)) startevent = Sim.SimEvent('Start') sstart = StartSignaller('Signal') Sim.activate(sstart, sstart.startSignals()) Sim.activate( activitynode[SANglobal.inTo], activitynode[SANglobal.inTo].waitup(SANglobal.inTo, startevent)) Sim.simulate(until=50) finishtimes.append(SANglobal.finishtime) plt.hist(finishtimes, bins=60, range=(0, 12), histtype='step', normed=True,
def runExperiment(args): # Set the random seed random.seed(args.seed) numpy.random.seed(args.seed) Simulation.initialize() servers = [] clients = [] workloadGens = [] muUpdaters = [] constants.NW_LATENCY_BASE = args.nwLatencyBase constants.NW_LATENCY_MU = args.nwLatencyMu constants.NW_LATENCY_SIGMA = args.nwLatencySigma constants.NUMBER_OF_CLIENTS = args.numClients assert args.expScenario != "" serviceRatePerServer = [] if (args.expScenario == "base"): # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=(args.serviceTime), serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif (args.expScenario == "multipleServiceTimeServers"): # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=((i + 1) * args.serviceTime), serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif (args.expScenario == "heterogenousStaticServiceTimeScenario"): baseServiceTime = args.serviceTime assert args.slowServerFraction >= 0 and args.slowServerFraction < 1.0 assert args.slowServerSlowness >= 0 and args.slowServerSlowness < 1.0 assert not (args.slowServerSlowness == 0 and args.slowServerFraction != 0) assert not (args.slowServerSlowness != 0 and args.slowServerFraction == 0) if (args.slowServerFraction > 0.0): slowServerRate = (args.serverConcurrency * 1/float(baseServiceTime)) *\ args.slowServerSlowness numSlowServers = int(args.slowServerFraction * args.numServers) slowServerRates = [slowServerRate] * numSlowServers numFastServers = args.numServers - numSlowServers totalRate = (args.serverConcurrency * 1 / float(args.serviceTime) * args.numServers) fastServerRate = (totalRate - sum(slowServerRates))\ / float(numFastServers) fastServerRates = [fastServerRate] * numFastServers serviceRatePerServer = slowServerRates + fastServerRates else: serviceRatePerServer = [ args.serverConcurrency * 1 / float(args.serviceTime) ] * args.numServers random.shuffle(serviceRatePerServer) # print sum(serviceRatePerServer), (1/float(baseServiceTime)) * args.numServers assert sum(serviceRatePerServer) > 0.99 *\ (1/float(baseServiceTime)) * args.numServers assert sum(serviceRatePerServer) <=\ (1/float(baseServiceTime)) * args.numServers # Start the servers for i in range(args.numServers): st = 1 / float(serviceRatePerServer[i]) serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=st, serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif (args.expScenario == "timeVaryingServiceTimeServers"): assert args.intervalParam != 0.0 assert args.timeVaryingDrift != 0.0 # Monitor to track service rates serverRateMonitor = Simulation.Monitor(name="ServerRateMonitor") # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=(args.serviceTime), serviceTimeModel=args.serviceTimeModel) mup = muUpdater.MuUpdater(serv, args.intervalParam, args.serviceTime, args.timeVaryingDrift, serverRateMonitor) Simulation.activate(mup, mup.run(), at=0.0) muUpdaters.append(mup) servers.append(serv) else: print "Unknown experiment scenario" sys.exit(-1) baseDemandWeight = 1.0 clientWeights = [] assert args.highDemandFraction >= 0 and args.highDemandFraction < 1.0 assert args.demandSkew >= 0 and args.demandSkew < 1.0 assert not (args.demandSkew == 0 and args.highDemandFraction != 0) assert not (args.demandSkew != 0 and args.highDemandFraction == 0) if (args.highDemandFraction > 0.0 and args.demandSkew >= 0): heavyClientWeight = baseDemandWeight *\ args.demandSkew/args.highDemandFraction numHeavyClients = int(args.highDemandFraction * args.numClients) heavyClientWeights = [heavyClientWeight] * numHeavyClients lightClientWeight = baseDemandWeight *\ (1 - args.demandSkew)/(1 - args.highDemandFraction) numLightClients = args.numClients - numHeavyClients lightClientWeights = [lightClientWeight] * numLightClients clientWeights = heavyClientWeights + lightClientWeights else: clientWeights = [baseDemandWeight] * args.numClients assert sum(clientWeights) > 0.99 * args.numClients assert sum(clientWeights) <= args.numClients # Start the clients for i in range(args.numClients): c = client.Client(id_="Client%s" % (i), serverList=servers, replicaSelectionStrategy=args.selectionStrategy, accessPattern=args.accessPattern, replicationFactor=args.replicationFactor, backpressure=args.backpressure, shadowReadRatio=args.shadowReadRatio, rateInterval=args.rateInterval, cubicC=args.cubicC, cubicSmax=args.cubicSmax, cubicBeta=args.cubicBeta, hysterisisFactor=args.hysterisisFactor, demandWeight=clientWeights[i], costExponent=args.costExponent, concurrencyWeight=args.concurrencyWeight) clients.append(c) # Start workload generators (analogous to YCSB) latencyMonitor = Simulation.Monitor(name="Latency") # This is where we set the inter-arrival times based on # the required utilization level and the service time # of the overall server pool. arrivalRate = 0 interArrivalTime = 0 if (len(serviceRatePerServer) > 0): print serviceRatePerServer arrivalRate = (args.utilization * sum(serviceRatePerServer)) interArrivalTime = 1 / float(arrivalRate) elif (args.expScenario == "timeVaryingServiceTimeServers"): mu = 1 / float(args.serviceTime) mu_dot_D = mu * args.timeVaryingDrift avg_mu = (mu + mu_dot_D) / 2.0 arrivalRate = args.utilization *\ (args.numServers * args.serverConcurrency * avg_mu) interArrivalTime = 1 / float(arrivalRate) print "avg_mu", avg_mu, "mu", mu, "mu.D", mu_dot_D print "serviceTime", args.serviceTime print "interArrivalTime", interArrivalTime,\ "interArrivalTimeMu",\ 1/(args.numServers * args.utilization * args.serverConcurrency * mu),\ "interArrivalTimeMuD",\ 1/(args.numServers * args.utilization * args.serverConcurrency * mu_dot_D) print "capacity", interArrivalTime/args.utilization,\ "capacityMu",\ 1/(args.numServers * args.serverConcurrency * mu),\ "capacityMuD",\ 1/(args.numServers * args.serverConcurrency * mu_dot_D) else: arrivalRate = args.numServers *\ (args.utilization * args.serverConcurrency * 1/float(args.serviceTime)) interArrivalTime = 1 / float(arrivalRate) print "serviceTime", args.serviceTime print "interArrivalTime", interArrivalTime for i in range(args.numWorkload): w = workload.Workload(i, latencyMonitor, clients, args.workloadModel, interArrivalTime * args.numWorkload, args.numRequests / args.numWorkload, args.batchSizeModel, args.batchSizeParam) Simulation.activate(w, w.run(), at=0.0), workloadGens.append(w) # Begin simulation Simulation.simulate(until=args.simulationDuration) # # Print a bunch of timeseries # pendingRequestsFD = open( "../%s/%s_PendingRequests" % (args.logFolder, args.expPrefix), 'w') waitMonFD = open("../%s/%s_WaitMon" % (args.logFolder, args.expPrefix), 'w') actMonFD = open("../%s/%s_ActMon" % (args.logFolder, args.expPrefix), 'w') latencyFD = open("../%s/%s_Latency" % (args.logFolder, args.expPrefix), 'w') latencyTrackerFD = open( "../%s/%s_LatencyTracker" % (args.logFolder, args.expPrefix), 'w') rateFD = open("../%s/%s_Rate" % (args.logFolder, args.expPrefix), 'w') tokenFD = open("../%s/%s_Tokens" % (args.logFolder, args.expPrefix), 'w') receiveRateFD = open( "../%s/%s_ReceiveRate" % (args.logFolder, args.expPrefix), 'w') edScoreFD = open("../%s/%s_EdScore" % (args.logFolder, args.expPrefix), 'w') serverRRFD = open("../%s/%s_serverRR" % (args.logFolder, args.expPrefix), 'w') serverRateFD = open( "../%s/%s_serverRate" % (args.logFolder, args.expPrefix), 'w') for clientNode in clients: printMonitorTimeSeriesToFile(pendingRequestsFD, clientNode.id, clientNode.pendingRequestsMonitor) printMonitorTimeSeriesToFile(latencyTrackerFD, clientNode.id, clientNode.latencyTrackerMonitor) printMonitorTimeSeriesToFile(rateFD, clientNode.id, clientNode.rateMonitor) printMonitorTimeSeriesToFile(tokenFD, clientNode.id, clientNode.tokenMonitor) printMonitorTimeSeriesToFile(receiveRateFD, clientNode.id, clientNode.receiveRateMonitor) printMonitorTimeSeriesToFile(edScoreFD, clientNode.id, clientNode.edScoreMonitor) for serv in servers: printMonitorTimeSeriesToFile(waitMonFD, serv.id, serv.queueResource.waitMon) printMonitorTimeSeriesToFile(actMonFD, serv.id, serv.queueResource.actMon) printMonitorTimeSeriesToFile(serverRRFD, serv.id, serv.serverRRMonitor) print "------- Server:%s %s ------" % (serv.id, "WaitMon") print "Mean:", serv.queueResource.waitMon.mean() print "------- Server:%s %s ------" % (serv.id, "ActMon") print "Mean:", serv.queueResource.actMon.mean() if (len(muUpdaters) > 0): printMonitorTimeSeriesToFile(serverRateFD, "0", muUpdaters[0].serviceRateMonitor) print "------- Latency ------" print "Mean Latency:",\ sum([float(entry[1].split()[0]) for entry in latencyMonitor])\ / float(len(latencyMonitor)) printMonitorTimeSeriesToFile(latencyFD, "0", latencyMonitor) assert args.numRequests == len(latencyMonitor)
def enqueue_task(self, task): executor = Executor(self, task) Simulation.activate(executor, executor.run(), Simulation.now())
Simulation.activate(c, c.checkout()) arrival = random.expovariate(float(AVGCUST)/CLOSING) yield hold, self, arrival class Monitor2(Monitor): def __init__(self): Monitor.__init__(self) self.min, self.max = (int(2**31-1),0) def tally(self, x): Monitor.tally(self, x) self.min = min(self.min, x) self.max = max(self.max, x) for run in range(RUNS): waittime = Monitor2() checkouttime = Monitor2() checkout_aisle = Simulation.Resource(AISLES) Simulation.initialize() cf = Customer_Factory() Simulation.activate(cf, cf.run(), 0.0) Simulation.simulate(until=CLOSING) #print "Customers:", checkouttime.count() print "Waiting time average: %.1f" % waittime.mean(), \ "(std dev %.1f, maximum %.1f)" % (sqrt(waittime.var()),waittime.max) #print "Checkout time average: %1f" % checkouttime.mean(), \ # "(standard deviation %.1f)" % sqrt(checkouttime.var()) print 'AISLES:', AISLES, ' ITEM TIME:', ITEMTIME
duck_name = "Duck_" + str( self.duck_number ) print "%10.2f" % ( self.sim.now() ), "making Duck:", duck_name self.name = duck_name d = Duck( duck_name, self.sim ) yield hold, self, random()*2000 #colocar na redde yield put, self, self.duckflock, [d] if __name__ == '__main__': simUntil = 50000 hunter_ammo = 180 hunter_accuracy_decile = 5 # municao hunter_switch_target = 2 mySim = Simulation() myDuckFlock = DuckFlock( "Duck Flock", "unbounded", "ducks", None, mySim ) myDuckFactory = DuckFactory( "My Duck Factory", simUntil, 200, myDuckFlock, mySim ) mySim.activate( myDuckFactory, myDuckFactory.execute() ) h = Hunter( "Fred", hunter_ammo, hunter_accuracy_decile, hunter_switch_target, myDuckFlock, mySim ) k = Hunter( "Dave", 180, 4, 4, myDuckFlock, mySim ) mySim.activate( h, h.shoot() ) mySim.activate( k, k.shoot() ) mySim.simulate( until = simUntil )
hostB = Host(name='Remote Host') # Create network network = Network() Host.network = network a_b_link = Link(hostFrom=hostA, hostTo=hostB, delay=100, jitter=10, packetLoss=0) b_a_link = Link(hostFrom=hostB, hostTo=hostA, delay=100, jitter=10, packetLoss=0) network.links.append(a_b_link) network.links.append(b_a_link) # Create algorithms transmitter = Transmitter(name='SynchA') receiver = Receiver('SnapB') simpy.activate(transmitter, transmitter.run(stateData, txRate)) # Connect hosts hostA.addSimplexConnection(names=[hostA.name, hostB.name], remoteHost=hostB, transmitter=transmitter, receiver=receiver) simpy.simulate(until=maxTime)
def simTransmission(self, receiver, packet): if not self.simPacketLoss(): packet.rxTime = packet.txTime + self.simDelay() receivePacket = ReceivePacket(receiver=receiver, packet=packet) simpy.activate(receivePacket, receivePacket.run())
def runExperiment(args): # Set the random seed random.seed(args.seed) numpy.random.seed(args.seed) Simulation.initialize() servers = [] clients = [] workloadGens = [] constants.NW_LATENCY_BASE = args.nwLatencyBase constants.NW_LATENCY_MU = args.nwLatencyMu constants.NW_LATENCY_SIGMA = args.nwLatencySigma constants.NUMBER_OF_CLIENTS = args.numClients assert args.expScenario != "" serviceRatePerServer = [] if (args.expScenario == "base"): # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=(args.serviceTime), serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif(args.expScenario == "multipleServiceTimeServers"): # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=((i + 1) * args.serviceTime), serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif(args.expScenario == "heterogenousStaticServiceTimeScenario"): baseServiceTime = args.serviceTime assert args.slowServerFraction >= 0 and args.slowServerFraction < 1.0 assert args.slowServerSlowness >= 0 and args.slowServerSlowness < 1.0 assert not (args.slowServerSlowness == 0 and args.slowServerFraction != 0) assert not (args.slowServerSlowness != 0 and args.slowServerFraction == 0) if(args.slowServerFraction > 0.0): slowServerRate = (args.serverConcurrency * 1/float(baseServiceTime)) *\ args.slowServerSlowness numSlowServers = int(args.slowServerFraction * args.numServers) slowServerRates = [slowServerRate] * numSlowServers numFastServers = args.numServers - numSlowServers totalRate = (args.serverConcurrency * 1/float(args.serviceTime) * args.numServers) fastServerRate = (totalRate - sum(slowServerRates))\ / float(numFastServers) fastServerRates = [fastServerRate] * numFastServers serviceRatePerServer = slowServerRates + fastServerRates else: serviceRatePerServer = [args.serverConcurrency * 1/float(args.serviceTime)] * args.numServers random.shuffle(serviceRatePerServer) # print sum(serviceRatePerServer), (1/float(baseServiceTime)) * args.numServers assert sum(serviceRatePerServer) > 0.99 *\ (1/float(baseServiceTime)) * args.numServers assert sum(serviceRatePerServer) <=\ (1/float(baseServiceTime)) * args.numServers # Start the servers for i in range(args.numServers): st = 1/float(serviceRatePerServer[i]) serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=st, serviceTimeModel=args.serviceTimeModel) servers.append(serv) elif(args.expScenario == "timeVaryingServiceTimeServers"): assert args.intervalParam != 0.0 assert args.timeVaryingDrift != 0.0 # Start the servers for i in range(args.numServers): serv = server.Server(i, resourceCapacity=args.serverConcurrency, serviceTime=(args.serviceTime), serviceTimeModel=args.serviceTimeModel) mup = muUpdater.MuUpdater(serv, args.intervalParam, args.serviceTime, args.timeVaryingDrift) Simulation.activate(mup, mup.run(), at=0.0) servers.append(serv) else: print "Unknown experiment scenario" sys.exit(-1) baseDemandWeight = 1.0 clientWeights = [] assert args.highDemandFraction >= 0 and args.highDemandFraction < 1.0 assert args.demandSkew >= 0 and args.demandSkew < 1.0 assert not (args.demandSkew == 0 and args.highDemandFraction != 0) assert not (args.demandSkew != 0 and args.highDemandFraction == 0) if(args.highDemandFraction > 0.0 and args.demandSkew >= 0): heavyClientWeight = baseDemandWeight *\ args.demandSkew/args.highDemandFraction numHeavyClients = int(args.highDemandFraction * args.numClients) heavyClientWeights = [heavyClientWeight] * numHeavyClients lightClientWeight = baseDemandWeight *\ (1 - args.demandSkew)/(1 - args.highDemandFraction) numLightClients = args.numClients - numHeavyClients lightClientWeights = [lightClientWeight] * numLightClients clientWeights = heavyClientWeights + lightClientWeights else: clientWeights = [baseDemandWeight] * args.numClients assert sum(clientWeights) > 0.99 * args.numClients assert sum(clientWeights) <= args.numClients # Start the clients for i in range(args.numClients): c = client.Client(id_="Client%s" % (i), serverList=servers, replicaSelectionStrategy=args.selectionStrategy, accessPattern=args.accessPattern, replicationFactor=args.replicationFactor, backpressure=args.backpressure, shadowReadRatio=args.shadowReadRatio, rateInterval=args.rateInterval, cubicC=args.cubicC, cubicSmax=args.cubicSmax, cubicBeta=args.cubicBeta, hysterisisFactor=args.hysterisisFactor, demandWeight=clientWeights[i]) clients.append(c) # Start workload generators (analogous to YCSB) latencyMonitor = Simulation.Monitor(name="Latency") # This is where we set the inter-arrival times based on # the required utilization level and the service time # of the overall server pool. arrivalRate = 0 interArrivalTime = 0 if (len(serviceRatePerServer) > 0): print serviceRatePerServer arrivalRate = (args.utilization * sum(serviceRatePerServer)) interArrivalTime = 1/float(arrivalRate) else: arrivalRate = args.numServers *\ (args.utilization * args.serverConcurrency * 1/float(args.serviceTime)) interArrivalTime = 1/float(arrivalRate) for i in range(args.numWorkload): w = workload.Workload(i, latencyMonitor, clients, args.workloadModel, interArrivalTime * args.numWorkload, args.numRequests/args.numWorkload) Simulation.activate(w, w.run(), at=0.0), workloadGens.append(w) # Begin simulation Simulation.simulate(until=args.simulationDuration) # # Print a bunch of timeseries # pendingRequestsFD = open("../%s/%s_PendingRequests" % (args.logFolder, args.expPrefix), 'w') waitMonFD = open("../%s/%s_WaitMon" % (args.logFolder, args.expPrefix), 'w') actMonFD = open("../%s/%s_ActMon" % (args.logFolder, args.expPrefix), 'w') latencyFD = open("../%s/%s_Latency" % (args.logFolder, args.expPrefix), 'w') latencyTrackerFD = open("../%s/%s_LatencyTracker" % (args.logFolder, args.expPrefix), 'w') rateFD = open("../%s/%s_Rate" % (args.logFolder, args.expPrefix), 'w') tokenFD = open("../%s/%s_Tokens" % (args.logFolder, args.expPrefix), 'w') receiveRateFD = open("../%s/%s_ReceiveRate" % (args.logFolder, args.expPrefix), 'w') edScoreFD = open("../%s/%s_EdScore" % (args.logFolder, args.expPrefix), 'w') for clientNode in clients: printMonitorTimeSeriesToFile(pendingRequestsFD, clientNode.id, clientNode.pendingRequestsMonitor) printMonitorTimeSeriesToFile(latencyTrackerFD, clientNode.id, clientNode.latencyTrackerMonitor) printMonitorTimeSeriesToFile(rateFD, clientNode.id, clientNode.rateMonitor) printMonitorTimeSeriesToFile(tokenFD, clientNode.id, clientNode.tokenMonitor) printMonitorTimeSeriesToFile(receiveRateFD, clientNode.id, clientNode.receiveRateMonitor) printMonitorTimeSeriesToFile(edScoreFD, clientNode.id, clientNode.edScoreMonitor) for serv in servers: printMonitorTimeSeriesToFile(waitMonFD, serv.id, serv.queueResource.waitMon) printMonitorTimeSeriesToFile(actMonFD, serv.id, serv.queueResource.actMon) print "------- Server:%s %s ------" % (serv.id, "WaitMon") print "Mean:", serv.queueResource.waitMon.mean() print "------- Server:%s %s ------" % (serv.id, "ActMon") print "Mean:", serv.queueResource.actMon.mean() print "------- Latency ------" print "Mean Latency:",\ sum([float(entry[1].split()[0]) for entry in latencyMonitor])/float(len(latencyMonitor)) printMonitorTimeSeriesToFile(latencyFD, "0", latencyMonitor) assert args.numRequests == len(latencyMonitor)
break print 'Bus has arrived at %s' % sim.now() class Breakdown(sim.Process): """Creator of periodic interruptions to break down the bus class.""" def __init__(self, myBus): sim.Process.__init__(self, name='Breakdown ' + myBus.name) self.bus = myBus def break_bus(self, interval): """Interrupt periodically self.myBus.""" while True: #driving time between breakdowns yield sim.hold, self, interval if self.bus.terminated(): break # signal "self.bus" to break itself down self.interrupt(self.bus) sim.initialize() bus = Bus('Bus') sim.activate(bus, bus.operate(repairduration=20, triplength=1000)) #create a breakdown object "br" for bus "bus", and br = Breakdown(bus) #activate it with driving time between breakdowns equal to 300 sim.activate(br, br.break_bus(300)) sim.simulate(until=4000) print 'SimPy: No more events at time %s' % sim.now()
class Breakdown(sim.Process): """Creator of periodic interruptions to break down the bus class.""" def __init__(self, myBus): sim.Process.__init__(self, name='Breakdown ' + myBus.name) self.bus = myBus def break_bus(self, interval): """Interrupt periodically self.myBus.""" while True: #driving time between breakdowns yield sim.hold, self, interval if self.bus.terminated(): break # signal "self.bus" to break itself down self.interrupt(self.bus) sim.initialize() bus = Bus('Bus') sim.activate(bus, bus.operate(repairduration=20, triplength=1000)) #create a breakdown object "br" for bus "bus", and br = Breakdown(bus) #activate it with driving time between breakdowns equal to 300 sim.activate(br, br.break_bus(300)) sim.simulate(until=4000) print 'SimPy: No more events at time %s' % sim.now()
settings = {} settings['reset_potential'] = -70 settings['spike_potential'] = 0 settings['threshold'] = -66.6 settings['left_window_constant'] = 20#(t+) settings['right_window_constant'] = 20#(t-) settings['learning_rate'] = 0.05# (A+) settings['stability'] = 1.05# (B) settings['weight_ceiling'] = 1.0 current_a = Current('current', 0, 'current', 26.6, 3.0) neuron_a = Neuron('neuron', 0, settings, 'off') set = [current_a, neuron_a] current_a.connect(neuron_a) for i in range(20): for neuron in set: event = Event(name = 'update') simpy.activate(event, event.update(neuron), delay = i) simpy.simulate(until = 20.0) x = list(range(len(neuron_a.spikes_record))) plot.plot(x, neuron_a.spikes_record) plot.show()