def main():
args = parse_args()
metrics.reset()
start_time = time.time()
logging.basicConfig(level=logging.INFO)
# Create a SimPy environment
env = simpy.Environment()
# Seed the random generator
random.seed(args.seed)
numpy.random.seed(args.seed)
# Parse network and get NetworkX object and ingress network list
network, ing_nodes = reader.read_network(args.network,
node_cap=10,
link_cap=10)
# Getting current SFC list, and the SF list of each SFC, and config
# use dummy placement and schedule for running simulator without algorithm
# TODO: make configurable via CLI
sf_placement = dummy_data.triangle_placement
schedule = dummy_data.triangle_schedule
# Getting current SFC list, and the SF list of each SFC, and config
sfc_list = reader.get_sfc(args.sf)
sf_list = reader.get_sf(args.sf, args.sfr)
config = reader.get_config(args.config)
# Create the simulator parameters object with the provided args
params = SimulatorParams(network,
ing_nodes,
sfc_list,
sf_list,
config,
args.seed,
sf_placement=sf_placement,
schedule=schedule)
log.info(params)
if args.trace:
trace = reader.get_trace(args.trace)
TraceProcessor(params, env, trace)
# Create a FlowSimulator object, pass the SimPy environment and params objects
simulator = FlowSimulator(env, params)
# Start the simulation
simulator.start()
# Run the simpy environment for the specified duration
env.run(until=args.duration)
# Record endtime and running_time metrics
end_time = time.time()
metrics.running_time(start_time, end_time)
# dump all metrics
log.info(metrics.metrics)
def init(self,
network_file,
service_functions_file,
config_file,
seed,
trace=None,
resource_functions_path=""):
# Initialize metrics, record start time
metrics.reset()
self.run_times = int(1)
self.start_time = time.time()
# Parse network and SFC + SF file
self.network, self.ing_nodes = reader.read_network(network_file,
node_cap=10,
link_cap=10)
self.sfc_list = reader.get_sfc(service_functions_file)
self.sf_list = reader.get_sf(service_functions_file,
resource_functions_path)
self.config = reader.get_config(config_file)
# Generate SimPy simulation environment
self.env = simpy.Environment()
# Instantiate the parameter object for the simulator.
self.params = SimulatorParams(self.network, self.ing_nodes,
self.sfc_list, self.sf_list, self.config,
seed)
# Trace handling
if trace:
trace = reader.get_trace(trace)
TraceProcessor(self.params, self.env, trace)
self.duration = self.params.run_duration
# Get and plant random seed
self.seed = seed
random.seed(self.seed)
numpy.random.seed(self.seed)
# Instantiate a simulator object, pass the environment and params
self.simulator = FlowSimulator(self.env, self.params)
# Start the simulator
self.simulator.start()
# Run the environment for one step to get initial stats.
self.env.step()
# Parse the NetworkX object into a dict format specified in SimulatorState. This is done to account
# for changing node remaining capacities.
# Also, parse the network stats and prepare it in SimulatorState format.
self.parse_network()
self.network_metrics()
# Record end time and running time metrics
self.end_time = time.time()
metrics.running_time(self.start_time, self.end_time)
simulator_state = SimulatorState(self.network_dict,
self.simulator.params.sf_placement,
self.sfc_list, self.sf_list,
self.traffic, self.network_stats)
# self.writer.write_state_results(self.env, simulator_state)
return simulator_state
def init(self, seed):
# Reset predictor class at beginning of every init
if self.prediction:
self.predictor = TrafficPredictor(self.params, self.lstm_predictor)
# increment episode count
self.episode += 1
self.params.episode += 1
# reset network caps and available SFs:
reader.reset_cap(self.network)
# Initialize metrics, record start time
self.params.run_times = int(1)
self.start_time = time.time()
# Generate SimPy simulation environment
self.env = simpy.Environment()
self.env.process(self.writer.begin_writing(self.env, self.params))
self.params.metrics.reset_metrics()
# Instantiate the parameter object for the simulator.
if self.params.use_states and 'trace_path' in self.config:
logger.warning('Two state model and traces are both activated, thi will cause unexpected behaviour!')
if self.params.use_states:
if self.params.in_init_state:
self.params.in_init_state = False
# else:
self.env.process(self.params.start_mmpp(self.env))
self.duration = self.params.run_duration
# Get and plant random seed
self.seed = seed
random.seed(self.seed)
numpy.random.seed(self.seed)
self.params.reset_flow_lists()
# generate flow lists 1x here since we are in `init()`
self.params.generate_flow_lists()
# Instantiate a simulator object, pass the environment and params
self.simulator = FlowSimulator(self.env, self.params)
# Trace handling
if 'trace_path' in self.config:
TraceProcessor(self.params, self.env, self.trace, self.simulator)
# Start the simulator
self.simulator.start()
# TODO: Create runner here
controller_cls = eval(self.params.controller_class)
self.controller = controller_cls(self.env, self.params, self.simulator)
# # Run the environment for one step to get initial stats.
# self.env.step()
# # Parse the NetworkX object into a dict format specified in SimulatorState. This is done to account
# # for changing node remaining capacities.
# # Also, parse the network stats and prepare it in SimulatorState format.
# self.parse_network()
# self.network_metrics()
# Record end time and running time metrics
self.end_time = time.time()
self.params.metrics.running_time(self.start_time, self.end_time)
simulator_state = self.controller.get_init_state()
# Check to see if traffic prediction is enabled to provide future traffic not current traffic
# if self.prediction:
# requested_traffic = self.get_current_ingress_traffic()
# self.predictor.predict_traffic(self.env.now, current_traffic=requested_traffic)
# stats = self.params.metrics.get_metrics()
# self.traffic = stats['run_total_requested_traffic']
# simulator_state = SimulatorState(self.network_dict, self.simulator.params.sf_placement, self.sfc_list,
# self.sf_list, self.traffic, self.network_stats)
# logger.debug(f"t={self.env.now}: {simulator_state}")
# set time stamp to calculate runtime of next apply call
self.last_apply_time = time.time()
# Check to see if init called in warmup, if so, set warmup to false
# This is to allow for better prediction and better overall control
# in the future
return simulator_state
def init(self, seed):
# reset network caps and available SFs:
reader.reset_cap(self.network)
# Initialize metrics, record start time
metrics.reset_metrics()
self.run_times = int(1)
self.start_time = time.time()
# Parse network and SFC + SF file
# Generate SimPy simulation environment
self.env = simpy.Environment()
self.params = SimulatorParams(self.network, self.ing_nodes,
self.sfc_list, self.sf_list, self.config)
# Instantiate the parameter object for the simulator.
if self.params.use_states and 'trace_path' in self.config:
logger.warning(
'Two state model and traces are both activated, thi will cause unexpected behaviour!'
)
if self.params.use_states:
if self.params.in_init_state:
self.params.in_init_state = False
else:
self.params.update_state()
self.duration = self.params.run_duration
# Get and plant random seed
self.seed = seed
random.seed(self.seed)
numpy.random.seed(self.seed)
# Instantiate a simulator object, pass the environment and params
self.simulator = FlowSimulator(self.env, self.params)
# Start the simulator
self.simulator.start()
# Trace handling
if 'trace_path' in self.config:
trace_path = os.path.join(os.getcwd(), self.config['trace_path'])
trace = reader.get_trace(trace_path)
TraceProcessor(self.params, self.env, trace, self.simulator)
# Run the environment for one step to get initial stats.
self.env.step()
# Parse the NetworkX object into a dict format specified in SimulatorState. This is done to account
# for changing node remaining capacities.
# Also, parse the network stats and prepare it in SimulatorState format.
self.parse_network()
self.network_metrics()
# Record end time and running time metrics
self.end_time = time.time()
metrics.running_time(self.start_time, self.end_time)
simulator_state = SimulatorState(self.network_dict,
self.simulator.params.sf_placement,
self.sfc_list, self.sf_list,
self.traffic, self.network_stats)
logger.debug(f"t={self.env.now}: {simulator_state}")
return simulator_state