def test_flow_size(self, topo_strategy_entities: List, combinations: List = None): for topo_strategy_entity in topo_strategy_entities: # set topology strategy self.topo_generator.topo_strategy = TopoStrategyFactory.get_instance( **topo_strategy_entity) # generate topology graph: nx.Graph = self.topo_generator.generate_core_topo() attached_edge_nodes_num: int = config.GRAPH_CONFIG['edge-node-num'] attached_edge_nodes: List[ NodeId] = self.topo_generator.attach_edge_nodes( graph, attached_edge_nodes_num) self.topo_generator.draw(graph) # generate flows flows: List[Flow] = FlowGenerator.generate_flows( edge_nodes=attached_edge_nodes, graph=graph, flow_num=config.TESTING['flow-size'][1]) for combination in combinations: for i in range(config.TESTING['flow-size'][0], config.TESTING['flow-size'][1] + 1, config.TESTING['x-axis-gap']): solver: Solver = Solver( nx_graph=graph, flows=flows[:i], topo_strategy=topo_strategy_entity['strategy'], routing_strategy=combination['routing_strategy'], scheduling_strategy=combination['scheduling_strategy'], allocating_strategy=combination['allocating_strategy'], reliability_strategy=combination[ 'reliability_strategy']) # origin method solution = solver.generate_init_solution( ) # get initial solution solution.generate_solution_name( prefix='b_fz_t{}_n{}_'.format( self.test_round, len(solution.graph.nodes))) Analyzer.analyze_flow_size(solution, target_filename=os.path.join( config.flow_size_res_dir, solution.solution_name)) # solution.generate_solution_name( # prefix='b_fz_t{}_n{}_f{}_'.format(self.test_round, len(solution.graph.nodes), i)) # Analyzer.analyze_flow_routes_repetition_degree( # solution, # target_filename=os.path.join(config.flow_routes_repetition_degree_dir, # solution.solution_name)) # optimized method if config.OPTIMIZATION['enable'] is False: continue solution = solver.optimize() # optimize solution.generate_solution_name( prefix='o_fz_t{}_n{}_'.format( self.test_round, len(solution.graph.nodes))) Analyzer.analyze_flow_size(solution, target_filename=os.path.join( config.flow_size_res_dir, solution.solution_name))
def test_allocation_methods(self, topo_strategy_entities: List, combinations: List = None): for topo_strategy_entity in topo_strategy_entities: for i in range(config.GRAPH_CONFIG['core-node-num'][0], config.GRAPH_CONFIG['core-node-num'][1] + 1, config.TESTING['x-axis-gap']): # set topology strategy topo_strategy_entity['n'] = i self.topo_generator.topo_strategy = TopoStrategyFactory.get_instance(**topo_strategy_entity) # generate topology graph: nx.Graph = self.topo_generator.generate_core_topo() attached_edge_nodes_num: int = config.GRAPH_CONFIG['edge-node-num'] attached_edge_nodes: List[NodeId] = self.topo_generator.attach_edge_nodes(graph, attached_edge_nodes_num) # self.topo_generator.draw(graph) # generate flows flows: List[Flow] = FlowGenerator.generate_flows(edge_nodes=attached_edge_nodes, graph=graph, flow_num=config.TESTING['flow-size'][1]) for combination in combinations: solver: Solver = Solver(nx_graph=graph, flows=flows, topo_strategy=topo_strategy_entity['strategy'], routing_strategy=combination['routing_strategy'], scheduling_strategy=combination['scheduling_strategy'], allocating_strategy=combination['allocating_strategy'], reliability_strategy=combination['reliability_strategy']) # origin method solution = solver.generate_init_solution() # get initial solution solution.generate_solution_name( prefix='b_gz_t{}_f{}_'.format(self.test_round, len(flows))) Analyzer.analyze_flow_size( solution, target_filename=os.path.join(config.graph_size_res_dir, solution.solution_name)) if config.TESTING['draw-gantt-chart'] is True: solver.draw_gantt_chart(solution) logger.info('Native Objective: ' + str(solver.objective_function(solution))) # optimized method if config.OPTIMIZATION['enable'] is False or \ combination['allocating_strategy'] == ALLOCATING_STRATEGY.AEAPBF_ALLOCATING_STRATEGY or \ combination['allocating_strategy'] == ALLOCATING_STRATEGY.AEAPWF_ALLOCATING_STRATEGY or \ combination['routing_strategy'] == ROUTING_STRATEGY.DIJKSTRA_SINGLE_ROUTING_STRATEGY: continue solution = solver.optimize() # optimize solution.generate_solution_name( prefix='o_gz_t{}_f{}_'.format(self.test_round, len(flows))) Analyzer.analyze_flow_size( solution, target_filename=os.path.join(config.graph_size_res_dir, solution.solution_name)) if config.TESTING['draw-gantt-chart'] is True: solver.draw_gantt_chart(solution) logger.info('Optimal Objective: ' + str(solver.objective_function(solution)))
def test_reliability_strategy(self): solver: Solver = Solver( nx_graph=self.graph, flows=self.flows, topo_strategy=None, routing_strategy=config.GRAPH_CONFIG['routing_strategy'], scheduling_strategy=config.GRAPH_CONFIG['scheduling_strategy'], allocating_strategy=config.GRAPH_CONFIG['allocating_strategy'], reliability_strategy=config.GRAPH_CONFIG['reliability-strategy']) self.solution = solver.generate_init_solution() solver.draw_gantt_chart(self.solution) # draw gantt chart target_filename: str = os.path.join( config.flow_routes_repetition_degree_dir, self.solution.solution_name) Analyzer.analyze_flow_routes_repetition_degree( self.solution, target_filename=target_filename)
def run_test(self, combinations: List = None): for combination in combinations: # origin method solver: Solver = Solver(nx_graph=self.graph, flows=self.flows[:], topo_strategy=None, routing_strategy=combination['routing_strategy'], scheduling_strategy=combination['scheduling_strategy'], allocating_strategy=combination['allocating_strategy'], reliability_strategy=combination['reliability_strategy']) solution = solver.generate_init_solution() solution.generate_solution_name(prefix='b_fixed_f{}_n{}_'.format(10, 10)) Analyzer.analyze_per_flow( solution, target_filename=os.path.join(config.solutions_res_dir, solution.solution_name)) if config.TESTING['draw-gantt-chart'] is True: solver.draw_gantt_chart(solution) logger.info('Native Objective: ' + str(solver.objective_function(solution))) # optimization method if config.OPTIMIZATION['enable'] is False or \ combination['allocating_strategy'] == ALLOCATING_STRATEGY.AEAPBF_ALLOCATING_STRATEGY or \ combination['allocating_strategy'] == ALLOCATING_STRATEGY.AEAPWF_ALLOCATING_STRATEGY or \ combination['routing_strategy'] == ROUTING_STRATEGY.DIJKSTRA_SINGLE_ROUTING_STRATEGY: continue solution = solver.optimize() # optimize solution.generate_solution_name(prefix='o_fixed_f{}_n{}_'.format(10, 10)) Analyzer.analyze_per_flow( solution, target_filename=os.path.join(config.solutions_res_dir, solution.solution_name)) if config.TESTING['draw-gantt-chart'] is True: solver.draw_gantt_chart(solution) logger.info('Optimal Objective: ' + str(solver.objective_function(solution))) # create network solver.save_solution(solution=solution) # save solution tsn_network_factory: TSNNetworkFactory = TSNNetworkFactory() tsn_network: TSNNetwork = tsn_network_factory.product( solution_filename=solution.solution_name, enhancement_enable=config.XML_CONFIG['enhancement-tsn-switch-enable']) tsn_network = tsn_network node_edge_mac_info = tsn_network_factory.node_edge_mac_info # create test scenario ConfigFileGenerator.create_test_scenario(tsn_network=tsn_network, solution=solution, node_edge_mac_info=node_edge_mac_info)
def test_flow_size(self): topo_generator: TopoGenerator = TopoGenerator() for topo_strategy_entity in config.GRAPH_CONFIG['topo-strategy']: topo_strategy: TopoStrategy = TopoStrategyFactory.get_instance( **topo_strategy_entity) topo_generator.topo_strategy = topo_strategy for test_round in range(config.TESTING['round'][0], config.TESTING['round'][1] + 1): self.round = test_round # generate topology graph: nx.Graph = topo_generator.generate_core_topo() attached_edge_nodes_num: int = config.GRAPH_CONFIG[ 'edge-node-num'] attached_edge_nodes: List[ NodeId] = topo_generator.attach_edge_nodes( graph, attached_edge_nodes_num) topo_generator.draw(graph) # generate flows flows: List[Flow] = FlowGenerator.generate_flows( edge_nodes=attached_edge_nodes, graph=graph, flow_num=config.TESTING['flow-size'][1]) for i in range(config.TESTING['flow-size'][0], config.TESTING['flow-size'][1] + 1, config.TESTING['x-axis-gap']): solver: Solver = Solver( nx_graph=graph, flows=flows[:i], topo_strategy=topo_strategy_entity['strategy'], routing_strategy=config. GRAPH_CONFIG['routing-strategy'], scheduling_strategy=config. GRAPH_CONFIG['scheduling-strategy'], allocating_strategy=config. GRAPH_CONFIG['allocating-strategy'], reliability_strategy=config. GRAPH_CONFIG['reliability-strategy']) try: import time import os # origin method self.solution = solver.generate_init_solution( ) # get initial solution self.solution.generate_solution_name( prefix='b_fz_t{}_n{}_'.format( test_round, len(self.solution.graph.nodes))) Analyzer.analyze_flow_size( self.solution, target_filename=os.path.join( config.flow_size_res_dir, self.solution.solution_name)) self.solution.generate_solution_name( prefix='b_fz_t{}_n{}_f{}_'.format( test_round, len(self.solution.graph.nodes), i)) Analyzer.analyze_flow_routes_repetition_degree( self.solution, target_filename=os.path.join( config.flow_routes_repetition_degree_dir, self.solution.solution_name)) if config.OPTIMIZATION['enable'] is True: # optimized method self.solution = solver.optimize() # optimize self.solution.generate_solution_name( prefix='o_fz_t{}_n{}_'.format( test_round, len( self.solution.graph.nodes))) Analyzer.analyze_flow_size( self.solution, target_filename=os.path.join( config.flow_size_res_dir, self.solution.solution_name)) self.solution.generate_solution_name( prefix='o_fz_t{}_n{}_f{}_'.format( test_round, len(self.solution.graph.nodes), i)) Analyzer.analyze_flow_routes_repetition_degree( self.solution, target_filename=os.path.join( config.flow_routes_repetition_degree_dir, self.solution.solution_name)) except: # save flows if error happen FlowGenerator.save_flows(flows)