def setUp(self): self.env = sp.RealtimeEnvironment(**rtEnvFastConfig) self.SERVER_COUNT = 20 self.servers = [] for i in range(self.SERVER_COUNT): self.servers.append(MockServer())
def run(): #env = simpy.Environment() env = simpy.RealtimeEnvironment( factor=.4) # factor= how fast the simulation runs (.4 = 40% speed) env.process(simulation(env)) env.run(until=200 ) # until= amount of time that the simulation will run (200 ticks)
def network_setup(realtime=False): import simpy if not realtime: env = simpy.Environment() else: env = simpy.RealtimeEnvironment(strict=False, factor=2) available_links = simpy.FilterStore(env) pending_messages = simpy.FilterStore(env) send_messages = simpy.Store(env) log = simpy.Store(env) return Network(env, available_links, pending_messages, send_messages, log)
def __init__(self, number_of_fireflies, period=20, nudge=4, neighbor_distance=50): # Save the parameters of the simulation self.n = number_of_fireflies self.p = period self.blink_duration = 1 self.canvas_length = 1600 # Default is 1600 self.canvas_width = 800 # Default is 800 self.nudge = nudge self.neighbor_distance = neighbor_distance self.message_pipes = {} self.messages = {} self.next_blink_at = {} self.last_nudged = {} self.neighbors = {} # Initialize the positions of fireflies xs = sample(range(self.canvas_length), self.n) ys = sample(range(self.canvas_width), self.n) self.fireflies_positions = zip(xs, ys) # Initialize the neighbors dictionary for x, y in self.fireflies_positions: self.neighbors[(x, y)] = [] for x1, y1 in self.fireflies_positions: for x2, y2 in self.fireflies_positions: if (x1, y1) != (x2, y2) and sqrt( (x2 - x1)**2 + (y2 - y1)**2) < self.neighbor_distance: self.neighbors[(x1, y1)].append((x2, y2)) neighbor_counts = [len(self.neighbors[i]) for i in self.neighbors] print "Average neighbors:", sum(neighbor_counts) / float( len(neighbor_counts)) # Initialize pygame library pygame.init() self.space = pygame.display.set_mode( (self.canvas_length, self.canvas_width)) pygame.display.set_caption('Fireflies') # Set the background color as black self.space.fill(const_black) # Initialize SimPy environment self.simpy_env = simpy.RealtimeEnvironment(factor=0.1) for x, y in self.fireflies_positions: random_start = randint(1, self.p) self.simpy_env.process(self.__firefly_control(x, y, random_start)) self.message_pipes[(x, y)] = simpy.Store(self.simpy_env) self.messages[(x, y)] = 0 self.last_nudged[(x, y)] = 0
def __init__(self, pixelSpan = 720, distSpan = 10, dt = 100, envMap = None, bot = None, visualize = True): threading.Thread.__init__(self) self.daemon = True self.pixelSpan = pixelSpan self.distSpan = distSpan self.dt = dt/1000 # converting to milliseconds self.envMap = envMap self.currMap = envMap self.bot = bot self.visualize = visualize self.env = simpy.RealtimeEnvironment(strict=False) self.active = True self.paused = False self.obstacles = [] self.landmarks = None if self.visualize is True: self.win = display.Window('Simulation', height = self.pixelSpan, dt = dt, endSimFunc = self.end, toggleSimFunc = self.toggle, scale = 0.7) bot.attachSim(self, self.currMap) self.stepProc = self.env.process(self.step(self.env))
def setUp(self): self.env = sp.RealtimeEnvironment(**rtEnvFastConfig) pass
import simpy import paho.mqtt.publish as publish import time from datetime import datetime import os def clock(env, name, tick): while True: print(name, env.now) yield env.timeout(tick) # Process as fast as possible, in this example two events are running in the interval of 1 and 2 s till 5 seconds env = simpy.RealtimeEnvironment() # env.process(clock(env, 'fast', 1)) # env.process(clock(env, 'slow', 2)) # env.run(until=5) # Creating processes from events, here three speakers take turn and speak infront of an audience def speaker(env, speaker): yield env.timeout(3) valx = f'Speaker {speaker} finishes his speech at {env.now} interval on time {datetime.now()}' with open("testfile.txt", "a") as outfile: outfile.write(valx) outfile.write('\n') return valx # publish.single("simpy/test", payload=f'Speaker {speaker} finishes his speech', hostname="localhost",port=1883)
def setUp(self): self.env = sp.RealtimeEnvironment(**rtEnvFastConfig) self.llb = LocalLoadBalancer(self.env)
from context import pyfarmsim from pyfarmsim.server import Server from pyfarmsim.loadbalancer import GlobalLoadBalancer from pyfarmsim.webrequest import WebRequest import simpy as sp import random from savecsv import savecsv random.seed(object()) env = sp.RealtimeEnvironment(factor=0.1, strict=False) # Create 2 servers server_sautron = Server(env=env, capacity=2, length=100, name="Sautron") server_tenibres = Server(env=env, capacity=3, length=100, name="Tenibres") # Create a load balancer gll = GlobalLoadBalancer(route_config=GlobalLoadBalancer.TURNING, env=env, autostart=True) gll.add_server(server_sautron, server_tenibres) gll.admission_rate = 5 def request_generator(env, cloud_access, rate, number): for i in range(number): # Get inter request time interval interval = random.expovariate(rate) # Generate a request
def setUp(self): DebugPrint.DEBUG = True self.e = sp.RealtimeEnvironment(factor=0.1, strict=False) self.s = Server(self.e, 4, 10, "Corborant") self.e.process(usage_ask(self.e, self.s, 50, 0.5)) self.e.process(capacity_setter(self.e, self.s))
from context import pyfarmsim from pyfarmsim.server import Server, FullQueue from pyfarmsim.loadbalancer import GlobalLoadBalancer, LocalLoadBalancer from pyfarmsim.webrequest import WebRequest import simpy as sp import random from savecsv import savecsv from functools import partial random.seed(object()) env = sp.RealtimeEnvironment(strict=False, factor=0.2) # Create a Global Load Balancer gll = GlobalLoadBalancer(env, route_config=GlobalLoadBalancer.TURNING) gll.admission_rate = 50 # Create Local Load Balancers and Servers llbs = [] srvs = [] for x in range(4): llbs.append(LocalLoadBalancer(env, autostart=True)) llbs[-1].admission_rate = 10 srvs.append(Server(env, capacity=2, length=50)) llbs[-1].add_server(srvs[-1]) # Add the local load balancers to the list of VPMs the global loadbalancer # can forward requests to gll.add_server(*llbs) for i in range(4):
def setUp(self): self.env = sp.RealtimeEnvironment(**rtEnvFastConfig) self.lbss = LoadBalancerSingleServer(self.env)
yield env.timeout(1) return valx def moderator(env): for i in range(3): brd = f'Speaker {i+1} gets on to the stage at {env.now}' prom_formatter['caseId'].append(i+1) prom_formatter['Timestamp'].append(datetime.fromtimestamp(env.now)) prom_formatter['Activity'].append('Starts Speech') print(brd) val = yield env.process(speaker(env, i+1)) print(val) def invoker_api(time1,time2): env = simpy.Environment(initial_time=time.time()) sys.argv[1] = time1 sys.argv[2] = time2 env.process(moderator(env)) print(f'the time taken for each speaker is {sys.argv[1]} at an interval {sys.argv[2]}') env.run() if __name__ == "__main__": env = simpy.RealtimeEnvironment(initial_time=time.time()) env.process(moderator(env)) print(f'the time taken for each speaker is {sys.argv[1]} at an interval {sys.argv[2]}') env.run()
def main(): env=simpy.RealtimeEnvironment()
def source(env, server, users, interval): """Function as process of generating new transaction requests from users.""" # add a number of users for n in range(users): # process a new request env.process(request(env, server, n, random.randint(50, 150))) # we need to wait for the next users to request transactions yield env.timeout(random.expovariate(1.0 / interval)) # we need a new environment env = simpy.RealtimeEnvironment(factor=60, strict=True) # we need a new server server = simpy.Resource(env, capacity=10) # bind the monitored data to the monitor monitor = partial(monitor, monitored) # install a server monitor server_monitor(server, pre=monitor) # start generating users env.process(source(env, server, N_USERS, N_INTERVAL)) # run the simulation env.run()
def __init__(self, environment, realtime, trace, gui, buffers, used_productions, initial_time=0, environment_process=None, **kwargs): self.gui = environment and gui and GUI self.__simulation = simpy.Environment( initial_time=round(initial_time, 4)) self.__env = environment if self.__env: self.__env.gui = gui and GUI #set the GUI of the environment in the same way as this one; it is used so that Environment prints its output directly in simpy simulation self.__realtime = realtime if not self.gui and realtime: self.__simulation = simpy.RealtimeEnvironment() self.__trace = trace self.__dict_extra_proc = {key: None for key in buffers} self.__buffers = buffers self.__pr = used_productions self.__simulation.process(self.__procprocessGenerator__()) self.__interruptibles = {} #interruptible processes self.__dict_extra_proc_activate = {} for each in self.__dict_extra_proc: if each != self.__pr._PROCEDURAL: self.__dict_extra_proc[each] = self.__simulation.process( self.__extraprocessGenerator__(each) ) #create simulation processes for all buffers, store them in dict_extra_proc self.__dict_extra_proc_activate[each] = self.__simulation.event( ) #create simulation events for all buffers that control simulation flow (they work as locks) self.__proc_activate = self.__simulation.event( ) #special event (lock) for procedural module self.__procs_started = [ ] #list of processes that are started as a result of production rules #activate environment process, if environment present if self.__env: self.__proc_environment = self.__simulation.process( self.__envGenerator__(ep=environment_process, **kwargs)) self.__environment_activate = self.__simulation.event() self.__last_event = None #used when stepping thru simulation #here below -- simulation values, accessible by user self.current_event = None self.now = self.__simulation.now
def setUp(self): self.e = sp.RealtimeEnvironment(**rtEnvFastConfig) self.s = Server(env=self.e, capacity=2, length=3, name="TestServer")
import pygame import simpy from NetworkGraph import NetworkGraph env = simpy.RealtimeEnvironment(initial_time=0, factor=0.05, strict=False) pygame.init() size = width, height = 1000, 800 screen = pygame.display.set_mode(size) display = pygame.display image = pygame.image event = pygame.event graph = NetworkGraph(env, screen, display, image, event) env.process(graph) env.run(until=100)
def run(): #env = simpy.Environment() env = simpy.RealtimeEnvironment(factor=.4) env.process(simulation(env)) env.run(until=200)