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)
