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()
