def __init__(self, name: str, ue_config: UserEquipmentConfiguration, network_config: NetworkPacketConfiguration, core_id: str, t_initial: float = 0): super().__init__(name) ue_id = ue_config.ue_id service_config_list = ue_config.service_config_list service_ids = [service_config.service_id for service_config in service_config_list] self.ue_id = ue_id # Define and add components services = [Service(name + service.service_id, ue_id, service, network_config, t_initial, lite_id=core_id) for service in service_config_list] [self.add_component(service) for service in services] self.input_network = Port(NetworkPacket, 'input_network') self.output_network = Port(NetworkPacket, 'output_network') self.output_service_delay_report = Port(ServiceDelayReport, 'output_service_delay_report') self.add_in_port(self.input_network) self.add_out_port(self.output_network) self.add_out_port(self.output_service_delay_report) if len(services) > 1: # More than one service -> we add a multiplexer service_mux = UEServiceMux(name + '_service_mux', service_ids) self.add_component(service_mux) self.add_coupling(self.input_network, service_mux.input_network) for service in services: self.add_coupling(service_mux.outputs_network[service.service_id], service.input_network) else: # Otherwise, multiplexer is not required self.add_coupling(self.input_network, services[0].input_network) for service in services: self.add_coupling(service.output_network, self.output_network) self.add_coupling(service.output_service_delay_report, self.output_service_delay_report)
def __init__(self, name: str, rack_id: str, rack_node_config: RackNodeConfiguration, env_temp: float): self.rack_id = rack_id temp_model_name = rack_node_config.temp_model_name power_model_name = rack_node_config.pwr_model_name temp_model_config = rack_node_config.temp_model_config power_model_config = rack_node_config.pwr_model_config self.temp_model = self.rack_temp_factory.create_model( temp_model_name, **temp_model_config) self.power_model = self.rack_power_factory.create_model( power_model_name, **power_model_config) self.utilization = 0 self.max_u = 0 self.pu_reports = dict() self.power = 0 self.temp = env_temp self.env_temp = env_temp self.input_pu_report = Port(ProcessingUnitReport, name + '_input_pu_report') self.output_rack_report = Port(RackReport, name + '_output_rack_report') super().__init__(name=name) self.add_in_port(self.input_pu_report) self.add_out_port(self.output_rack_report)
def __init__(self, name, ap_id): super().__init__(name=name) self.ap_id = ap_id self.service_routing = dict() self.ue_connected = list() self.input_new_sdn_path = Port(NewSDNPath, name + '_input_new_sdn_path') self.input_connected_ue_list = Port(EnableChannels, name + '_input_connected_ue_list') self.input_service_routing_request = Port( GetDataCenterRequest, name + '_input_service_routing_request') self.input_radio = Port(NetworkPacket, name + '_input_radio') self.input_crosshaul = Port(NetworkPacket, name + '_input_crosshaul') self.output_service_routing_response = Port( GetDataCenterResponse, name + '_output_service_routing_response') self.output_crosshaul = Port(NetworkPacket, name + '_output_crosshaul') self.output_radio = Port(NetworkPacket, name + '_output_radio') self.add_in_port(self.input_new_sdn_path) self.add_in_port(self.input_connected_ue_list) self.add_in_port(self.input_service_routing_request) self.add_in_port(self.input_radio) self.add_in_port(self.input_crosshaul) self.add_out_port(self.output_service_routing_response) self.add_out_port(self.output_crosshaul) self.add_out_port(self.output_radio)
def __init__(self, name: str, nodes: Dict[str, NodeConfiguration], default_link: LinkConfiguration, topology: Dict[str, Dict[str, Dict[str, Union[LinkConfiguration, None]]]]): """ Network model for Mercury. It is defined as a directed graph :param name: name of the xDEVS atomic model :param nodes: dictionary containing the ID of every node in the network and their configuration. :param default_link: Default link configuration in case a given link in the topology is None :param topology: directed graph representing the network {node_from: {node_to: link_configuration}} """ super().__init__(name=name) self.input_node_location = Port(NodeLocation, 'input_new_location') self.input_data = Port(PhysicalPacket, 'input_data') self.output_link_report = Port(NetworkLinkReport, 'output_link_report') self.add_in_port(self.input_node_location) self.add_in_port(self.input_data) self.add_out_port(self.output_link_report) self.links = dict() # It contains the links of the network self.tx_overheads = dict() # It contains the transmission overhead of each link self.buffers = dict() # it contains the buffers of each transmitter self.outputs_node_to = dict() # it contains all the output ports for node_from, links in topology.items(): self.links[node_from] = dict() self.tx_overheads[node_from] = dict() self.buffers[node_from] = dict() for node_to, link_config in links.items(): if node_to not in self.outputs_node_to: self.outputs_node_to[node_to] = Port(PhysicalPacket, 'output_' + node_to) self.add_out_port(self.outputs_node_to[node_to]) conf = link_config if link_config is not None else default_link self.links[node_from][node_to] = Link(nodes[node_from], nodes[node_to], conf) self.tx_overheads[node_from][node_to] = 0 self.buffers[node_from][node_to] = deque()
class Generator(Atomic): def __init__(self, name, period): super().__init__(name) self.i_start = Port(Job, "i_start") self.i_stop = Port(Job, "i_stop") self.o_out = Port(Job, "o_out") self.add_in_port(self.i_start) self.add_in_port(self.i_stop) self.add_out_port(self.o_out) self.period = period self.job_counter = 1 def initialize(self): self.hold_in(PHASE_ACTIVE, self.period) def exit(self): pass def deltint(self): self.job_counter += 1 self.hold_in(PHASE_ACTIVE, self.period) def deltext(self, e): self.passivate() def lambdaf(self): self.o_out.add(Job(str(self.job_counter)))
def __init__(self, name: str, core_config, fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, ues: Dict[str, Tuple[float, ...]], aps: Dict[str, Tuple[float, ...]], edcs: Dict[str, Tuple[float, ...]], services_id: List[str]): super().__init__(name=name) self.sdn_controller_id = core_config.sdnc_id self.fed_mgmt_config = fed_mgmt_config self.network_config = network_config self.ues = ues self.aps = aps self.edcs = edcs sdn_strategy_name = core_config.sdn_strategy_name sdn_strategy_config = core_config.sdn_strategy_config self.sdn_strategy = SoftwareDefinedNetworkController.sdn_strategy_factory.create_strategy( sdn_strategy_name, aps, edcs, services_id, **sdn_strategy_config) self.designated_edcs = { ap_id: {service_id: None for service_id in services_id} for ap_id in aps } self.designated_aps = self._select_ue_bindings() self.input_node_location = Port(NodeLocation, 'input_node_location') self.input_network = Port(NetworkPacket, 'input_network') self.output_network = Port(NetworkPacket, 'output_network') self.add_in_port(self.input_node_location) self.add_in_port(self.input_network) self.add_out_port(self.output_network)
class Processor(Atomic): def __init__(self, name, proc_time): super().__init__(name) self.i_in = Port(Job, "i_in") self.o_out = Port(Job, "o_out") self.add_in_port(self.i_in) self.add_out_port(self.o_out) self.current_job = None self.proc_time = proc_time def initialize(self): self.passivate() def exit(self): pass def deltint(self): self.passivate() def deltext(self, e): if self.phase == PHASE_PASSIVE: self.current_job = self.i_in.get() self.hold_in(PHASE_ACTIVE, self.proc_time) def lambdaf(self): self.o_out.add(self.current_job)
def __init__(self, node_id_list, name="network_mux"): self.input = Port(NetworkPacket, 'input') self.outputs = { node_id: Port(NetworkPacket, 'output_' + node_id) for node_id in node_id_list } super().__init__(name, node_id_list) self.add_in_port(self.input) [self.add_out_port(port) for port in self.outputs.values()]
def __init__(self, name: str, edc_config: EdgeDataCenterConfiguration, services_config: Dict[str, ServiceConfiguration], fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, sdn_controller_id: str, lite=False): """ Edge Data Center xDEVS module :param str name: xDEVS module name :param EdgeDataCenterConfiguration edc_config: Edge Data Center Configuration :param dict services_config: dictionary with all the services_config configurations :param FederationManagementConfiguration fed_mgmt_config: Federation Management Application configuration :param NetworkPacketConfiguration network_config: network layer packets configuration :param str sdn_controller_id: Federation Controller ID """ super().__init__(name) # Unwrap EDC configuration values self.edc_id = edc_config.edc_id edc_location = edc_config.edc_location racks_config_list = edc_config.racks_configuration_list r_manager_config = edc_config.r_manager_config env_temp = edc_config.env_temp # Create and add submodules racks = [Rack(name + '_' + rack_id, racks_config_list[rack_id], services_config, env_temp) for rack_id in racks_config_list] rack_mux = RackMultiplexer(name + '_rack_mux', list(racks_config_list.keys())) r_manager = ResourceManager(name + '_r_manager', self.edc_id, edc_location, r_manager_config, services_config, env_temp) edc_interface = EdgeDataCenterInterface(name + '_edc_interface', self.edc_id, fed_mgmt_config, network_config, sdn_controller_id, lite) [self.add_component(rack) for rack in racks] self.add_component(rack_mux) self.add_component(r_manager) self.add_component(edc_interface) # Define input/output_ports port_type = NetworkPacket if lite else PhysicalPacket self.input_crosshaul = Port(port_type, name + '_input_crosshaul') self.output_crosshaul = Port(port_type, name + '_output_crosshaul') self.output_edc_report = Port(EdgeDataCenterReport, name + '_output_edc_report') self.add_in_port(self.input_crosshaul) self.add_out_port(self.output_crosshaul) self.add_out_port(self.output_edc_report) self._interface_r_manager_internal_couplings_spec(edc_interface, r_manager) # External couplings for resource manager self._r_manager_external_couplings(r_manager) # External couplings for EDC interface self._interface_external_couplings(edc_interface) # Internal couplings for interface and resource manager self._interface_r_manager_internal_couplings_std(edc_interface, r_manager) # Internal couplings for resource manager and processing units multiplexer self._r_manager_rack_mux_internal_couplings(r_manager, rack_mux) for rack in racks: # Internal couplings for processing units multiplexer and processing units self._p_units_mux_i_rack_internal_couplings(rack_mux, rack) # Internal couplings for resource manager and processing units self._resource_manager_rack_internal_couplings(r_manager, rack)
def __init__(self, name: str, edc_id: str, fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, sdn_controller_id: str, lite=False): """ Data Center Interface implementation for xDEVS :param name: Name of the stateless state machine xDEVS atomic module :param edc_id: ID of the corresponding Edge Data Center :param fed_mgmt_config: Federation Management application configuration :param network_config: network packets configuration :param sdn_controller_id: ID of the edge fed_controller_config controller """ self.edc_id = edc_id self.fed_mgmt_config = fed_mgmt_config self.network_config = network_config self.sdn_controller_id = sdn_controller_id self.lite = lite self.routing_table = dict() super().__init__(name=name) out_type = NetworkPacket if lite else PhysicalPacket self.input_crosshaul = Port(out_type, 'input_crosshaul') self.input_create_session_response = Port(CreateSessionResponsePacket, 'input_create_session_resp') self.input_ongoing_session_response = Port( OngoingSessionResponsePacket, 'input_ongoing_session_resp') self.input_remove_session_response = Port(RemoveSessionResponsePacket, 'input_remove_session_resp') self.input_edc_report = Port(EdgeDataCenterReport, 'input_edc_report') self.output_create_session_request = Port(CreateSessionRequestPacket, 'output_create_session') self.output_ongoing_session_request = Port(OngoingSessionRequestPacket, 'output_ongoing_session') self.output_remove_session_request = Port(RemoveSessionRequestPacket, 'output_remove_session') self.output_crosshaul = Port(out_type, 'output_crosshaul') self.add_in_port(self.input_crosshaul) self.add_in_port(self.input_create_session_response) self.add_in_port(self.input_ongoing_session_response) self.add_in_port(self.input_remove_session_response) self.add_in_port(self.input_edc_report) self.add_out_port(self.output_create_session_request) self.add_out_port(self.output_ongoing_session_request) self.add_out_port(self.output_remove_session_request) self.add_out_port(self.output_crosshaul)
def __init__(self, name: str, node_id: str, max_hops: int = 0): super().__init__(name=name) self.node_id = node_id self.max_hops = max_hops self.input = Port(PhysicalPacket, "input") self.output_node = Port(PhysicalPacket, "output_node") self.output_transmitter = Port(PhysicalPacket, "output_transmitter") self.add_in_port(self.input) self.add_out_port(self.output_node) self.add_out_port(self.output_transmitter)
def __init__(self, name, proc_time): super().__init__(name) self.i_in = Port(Job, "i_in") self.o_out = Port(Job, "o_out") self.add_in_port(self.i_in) self.add_out_port(self.o_out) self.current_job = None self.proc_time = proc_time
def __init__(self, name, proc_time): super().__init__(name) self.i_input = Port(Ball, 'i_input') self.o_output = Port(Ball, 'o_output') self.add_in_port(self.i_input) self.add_out_port(self.o_output) self.current_job = None self.proc_time = proc_time self.clock = 0
def __init__(self, name, period): super().__init__(name) self.i_start = Port(Job, "i_start") self.i_stop = Port(Job, "i_stop") self.o_out = Port(Job, "o_out") self.add_in_port(self.i_start) self.add_in_port(self.i_stop) self.add_out_port(self.o_out) self.period = period self.job_counter = 1
def __init__(self, name, service_ids): self.service_ids = service_ids self.input_network = Port(NetworkPacket, name + '_input_network') self.outputs_network = { service: Port(NetworkPacket, name + '_output_network_' + service) for service in service_ids } super().__init__(name, service_ids) self.add_in_port(self.input_network) [self.add_out_port(port) for port in self.outputs_network.values()]
def __init__(self, ue_ids_list, ap_ids_list, edc_ids_list, core_ids_list, name='shortcut'): node_id_list = [ *ue_ids_list, *ap_ids_list, *edc_ids_list, *core_ids_list ] assert len(node_id_list) == len(set(node_id_list)) self.ue_ids_list = ue_ids_list self.ap_ids_list = ap_ids_list self.edc_ids_list = edc_ids_list self.core_ids_list = core_ids_list self.input_xh = Port(PhysicalPacket, 'input_xh') self.input_radio_control = Port(PhysicalPacket, 'input_radio_control') self.input_radio_transport = Port(PhysicalPacket, 'input_radio_transport') self.outputs_xh = dict() self.outputs_radio_control = dict() self.outputs_radio_transport = dict() for node_id in [*ap_ids_list, *edc_ids_list, *core_ids_list]: self.outputs_xh[node_id] = Port(PhysicalPacket, 'output_xh_' + node_id) for out_ports in [(self.outputs_radio_control, 'control'), (self.outputs_radio_transport, 'transport')]: for node_id in [*ue_ids_list, *ap_ids_list]: out_ports[0][node_id] = Port( PhysicalPacket, 'output_{}_{}'.format(out_ports[1], node_id)) super().__init__(name, node_id_list) self.add_in_port(self.input_xh) self.add_in_port(self.input_radio_control) self.add_in_port(self.input_radio_transport) for node_id in [*ap_ids_list, *edc_ids_list, *core_ids_list]: self.add_out_port(self.outputs_xh[node_id]) for out_ports in [(self.outputs_radio_control, 'control'), (self.outputs_radio_transport, 'transport')]: for node_id in [*ue_ids_list, *ap_ids_list]: self.add_out_port(out_ports[0][node_id])
def __init__(self, name: str, ap_id: str, rac_config: RadioAccessNetworkConfiguration): """ Create an instance of AP service broadcast module. :param name: Name of the module :param ap_id: ID of the AP :param rac_config: Radio Access Control configuration """ super().__init__(name=name) self.ap_id = ap_id self.pss_period = rac_config.pss_period self.header = rac_config.header self.input_repeat = Port(str, 'input_repeat') self.output_pss = Port(PrimarySynchronizationSignal, 'output_pss') self.add_in_port(self.input_repeat) self.add_out_port(self.output_pss)
def __init__(self, name: str, core_config: CoreLayerConfiguration, rac_config: RadioAccessNetworkConfiguration, fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, aps: Dict[str, Tuple[float, ...]], edcs: Dict[str, Tuple[float, ...]], services_id: List[str]): """ Core Layer Module for Mercury Simulator :param name: Name of the Core layer XDEVS module :param core_config: Core Layer Configuration :param rac_config: :param fed_mgmt_config: :param network_config: :param aps: list of APs in the scenario :param edcs: list of EDCs in the scenario :param services_id: """ super().__init__(name) self.input_node_location = Port(NodeLocation, 'input_node_location') self.output_crosshaul = Port(PhysicalPacket, 'output_crosshaul') self.add_in_port(self.input_node_location) self.add_out_port(self.output_crosshaul) self.inputs_crosshaul = dict() self.sdnc_id = core_config.sdnc_id sdn_strategy_name = core_config.sdn_strategy_name sdn_strategy_config = core_config.sdn_strategy_config self.core_functions = {self.sdnc_id: SoftwareDefinedNetworkController(name + '_sdn', self.sdnc_id, fed_mgmt_config, network_config, aps, edcs, services_id, sdn_strategy_name, **sdn_strategy_config)} self.add_component(self.core_functions[self.sdnc_id]) self.add_coupling(self.input_node_location, self.core_functions[self.sdnc_id].input_node_location) if not rac_config.bypass_amf: self.amf_id = core_config.amf_id self.core_functions[self.amf_id] = AccessAndMobilityManagementFunction(name + '_amf', self.amf_id, rac_config, network_config) for core_function_id, core_function in self.core_functions.items(): self.add_component(core_function) self.inputs_crosshaul[core_function_id] = Port(PhysicalPacket, 'input_' + core_function_id) self.add_in_port(self.inputs_crosshaul[core_function_id]) self.add_coupling(self.inputs_crosshaul[core_function_id], core_function.input_crosshaul) self.add_coupling(core_function.output_crosshaul, self.output_crosshaul)
def __init__(self, name: str, radio_config: RadioConfiguration, ues: Dict[str, NodeConfiguration], aps: Dict[str, NodeConfiguration]): super().__init__(name) self.input_pbch = Port(PhysicalPacket, "input_pbch") self.input_repeat_location = Port(str, "input_repeat_location") self.output_node_location = Port(NodeLocation, "output_node_location") self.add_in_port(self.input_pbch) self.add_in_port(self.input_repeat_location) self.add_out_port(self.output_node_location) # Ports for PBCH channel self.outputs_pbch = dict() for ue_id in ues: self.outputs_pbch[ue_id] = Port(PhysicalPacket, "output_pbch_" + ue_id) self.add_out_port(self.outputs_pbch[ue_id]) # Create and add sub-components radio_config.define_nodes(aps, ues) nodes = {**aps, **ues} pbch = Network(name + "_pbch", nodes, radio_config.base_dl_config, radio_config.dl_template) nodes_mobility = Nodes(name + '_nodes', nodes) self.add_component(pbch) self.add_component(nodes_mobility) self.add_coupling(nodes_mobility.output_node_location, pbch.input_node_location) self.add_coupling(self.input_repeat_location, nodes_mobility.input_repeat_location) self.add_coupling(nodes_mobility.output_node_location, self.output_node_location) self.add_coupling(self.input_pbch, pbch.input_data) for ue_id in ues: self.add_coupling(pbch.outputs_node_to[ue_id], self.outputs_pbch[ue_id])
def __init__(self, name: str, ue_config: UserEquipmentConfiguration, rac_config: RadioAccessNetworkConfiguration, network_config: NetworkPacketConfiguration, t_initial: float = 0): """ User Equipment xDEVS model :param name: xDEVS model name :param ue_config: User Equipment Configuration :param rac_config: Radio Access Network service packets configuration :param network_config: Network packets configuration :param t_initial: Initial guard time in order to avoid identical simultaneous behavior between UEs """ super().__init__(name) # Unpack configuration parameters ue_id = ue_config.ue_id service_config_list = ue_config.service_config_list service_ids = [service_config.service_id for service_config in service_config_list] self.ue_id = ue_id # Define and add components antenna = UserEquipmentAntenna(name + '_antenna', ue_id, network_config) access_manager = AccessManager(name + '_access_manager', ue_id, rac_config) service_mux = UEServiceMux(name + '_service_mux', service_ids) services = [Service(name + service.service_id, ue_id, service, network_config, t_initial) for service in service_config_list] self.add_component(antenna) self.add_component(access_manager) self.add_component(service_mux) [self.add_component(service) for service in services] # I/O ports self.input_radio_bc = Port(PhysicalPacket, name + '_input_radio_bc') self.input_radio_control_dl = Port(PhysicalPacket, name + '_input_radio_control_dl') self.input_radio_transport_dl = Port(PhysicalPacket, name + '_input_radio_transport_dl') self.output_radio_control_ul = Port(PhysicalPacket, name + '_output_radio_control_ul') self.output_radio_transport_ul = Port(PhysicalPacket, name + '_output_radio_transport_ul') self.add_in_port(self.input_radio_bc) self.add_in_port(self.input_radio_control_dl) self.add_in_port(self.input_radio_transport_dl) self.add_out_port(self.output_radio_control_ul) self.add_out_port(self.output_radio_transport_ul) self.output_repeat_location = Port(str, 'output_repeat_location') self.output_service_delay_report = Port(ServiceDelayReport, 'output_service_delay_report') self.add_out_port(self.output_repeat_location) self.add_out_port(self.output_service_delay_report) self.external_couplings_antenna(antenna) self.external_couplings_access(access_manager) for service in services: self.external_couplings_service(service) self.internal_couplings_antenna_access(antenna, access_manager) self.internal_couplings_antenna_mux(antenna, service_mux) for service in services: self.internal_couplings_antenna_service(antenna, service) self.internal_couplings_access_service(access_manager, service) self.internal_couplings_mux_service(service_mux, service)
def __init__(self, name: str, sdn_controller_id: str, fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, aps: Dict[str, Tuple[float, ...]], edcs: Dict[str, Tuple[float, ...]], services_id: List[str], sdn_strategy_name: str, **kwargs): """ xDEVS model of a Software-Defined Network Controller for interconnecting Acess Points and Edge Data Centers :param name: Name of the XDEVS SDN Controller module :param sdn_controller_id: ID of the SDN controller :param fed_mgmt_config: fed_controller_config management application configuration :param network_config: network packets configuration :param aps: list of APs in the scenario :param edcs: list of EDCs in the scenario :param services_id: ID of all the services defined in the scenario :param sdn_strategy_name: Software-Defined Network linking strategy name :param kwargs: SDN linking strategy configuration parameters """ super().__init__(name=name) self.sdn_controller_id = sdn_controller_id self.fed_mgmt_config = fed_mgmt_config self.network_config = network_config self.aps = aps self.edcs = edcs self.sdn_strategy = self.sdn_strategy_factory.create_strategy( sdn_strategy_name, aps, edcs, services_id, **kwargs) self.designated_edcs = { ap_id: {service_id: None for service_id in services_id} for ap_id in aps } self.input_node_location = Port(NodeLocation, 'input_node_location') self.input_crosshaul = Port(PhysicalPacket, 'input_crosshaul') self.output_crosshaul = Port(PhysicalPacket, 'output_crosshaul') self.add_in_port(self.input_node_location) self.add_in_port(self.input_crosshaul) self.add_out_port(self.output_crosshaul)
class Player(Atomic): def __init__(self, name, proc_time): super().__init__(name) self.i_input = Port(Ball, 'i_input') self.o_output = Port(Ball, 'o_output') self.add_in_port(self.i_input) self.add_out_port(self.o_output) self.current_job = None self.proc_time = proc_time self.clock = 0 def initialize(self): self.hold_in(PHASE_WAIT, INFINITY) def deltint(self): self.clock += self.sigma if self.phase == PHASE_SEND: logging.info("%s launched ball number %d @ t = %.1f" % (self.name, self.current_job.count, self.clock)) self.current_job = None self.hold_in(PHASE_WAIT, INFINITY) def deltext(self, e): self.clock += e if self.phase == PHASE_WAIT: if self.i_input: job = self.i_input.get_single_value() logging.info("%s received ball number %d @ t = %.1f" % (self.name, job.count, self.clock)) self.current_job = job self.hold_in(PHASE_SEND, self.proc_time) def lambdaf(self): if self.phase == PHASE_SEND: self.current_job.count += 1 self.o_output.add_value(self.current_job) def exit(self): pass
def __init__(self, name: str, master_nodes: Dict[str, NodeConfiguration], slave_nodes: Dict[str, NodeConfiguration], default_link: LinkConfiguration, topology: Dict[str, Dict[str, Dict[str, None]]]): for node_from, links in topology.items(): assert node_from in slave_nodes for node_to in links: assert node_to in master_nodes super().__init__(name, master_nodes, slave_nodes, default_link, topology) self.input_channel_share = Port(ChannelShare, 'input_channel_share') self.add_in_port(self.input_channel_share)
def __init__(self, name: str, edcs_config: Dict[str, EdgeDataCenterConfiguration], services_config: Dict[str, ServiceConfiguration], fed_mgmt_config: FederationManagementConfiguration, network_config: NetworkPacketConfiguration, sdn_controller_id: str, lite=False): """ Edge Federation xDEVS model :param name: xDEVS module name :param edcs_config: Edge Data Centers configuration dict {EDC ID: EDC configuration} :param services_config: dictionary with all the services_config configurations :param fed_mgmt_config: Federation Management Application configuration :param network_config: network layer packets configuration :param sdn_controller_id: ID of the SDN controller """ super().__init__(name) # Unwrap configuration parameters self.n_edc = len(edcs_config) # Define sub-modules and add them to coupled module self.edcs = {edc_id: EdgeDataCenter(name + '_' + edc_id, edc_config, services_config, fed_mgmt_config, network_config, sdn_controller_id, lite) for edc_id, edc_config in edcs_config.items()} [self.add_component(edc) for edc in self.edcs.values()] port_type = NetworkPacket if lite else PhysicalPacket # Define input/output ports self.output_edc_report = Port(EdgeDataCenterReport, 'output_edc_report') self.output_crosshaul = Port(port_type, 'output_crosshaul') self.add_out_port(self.output_edc_report) self.add_out_port(self.output_crosshaul) self.inputs_crosshaul = dict() for edc_id, edc in self.edcs.items(): self.add_coupling(edc.output_edc_report, self.output_edc_report) self.add_coupling(edc.output_crosshaul, self.output_crosshaul) self.inputs_crosshaul[edc_id] = Port(port_type, 'input_crosshaul_' + edc_id) self.add_in_port(self.inputs_crosshaul[edc_id]) self.add_coupling(self.inputs_crosshaul[edc_id], edc.input_crosshaul)
class InitialBall(Atomic): def __init__(self, name): super().__init__(name) self.o_output = Port(Ball, 'o_output') self.add_out_port(self.o_output) def initialize(self): self.hold_in(PHASE_SEND, 0) def deltint(self): self.hold_in(PHASE_WAIT, INFINITY) def deltext(self, e): pass def lambdaf(self): ball = Ball() self.o_output.add_value(ball) def exit(self): pass
def __init__(self, name: str, amf_id: str, ran_config: RadioAccessNetworkConfiguration, network_config: NetworkPacketConfiguration): """ Access and Mobility Management Function xDEVS model :param name: name of the xDEVS module :param amf_id: ID of the Access and Mobility Management Function :param ran_config: RAN application Configuration :param network_config: network packets configuration """ super().__init__(name=name) self.amf_id = amf_id self.ran_ac_config = ran_config self.network_config = network_config self.path_table = dict() # {node_id: connected_ap} self.input_crosshaul = Port(PhysicalPacket, 'input_crosshaul') self.output_crosshaul = Port(PhysicalPacket, 'output_crosshaul') self.add_in_port(self.input_crosshaul) self.add_out_port(self.output_crosshaul)
def __init__(self, name, nodes_config: Dict[str, NodeConfiguration]): """ :param name: :param nodes_config: """ self.nodes_mobility = dict() for node_id, node_config in nodes_config.items(): self.nodes_mobility[node_id] = node_config.node_mobility self.nodes_location = dict() self.nodes_next_change = dict() for node_id, mobility in self.nodes_mobility.items(): self.nodes_location[node_id] = mobility.position self.nodes_next_change[node_id] = mobility.get_next_sigma(0) super().__init__(self.get_next_event(0), name) self.input_repeat_location = Port(str, 'input_repeat_location') self.output_node_location = Port(NodeLocation, 'output_node_location') self.add_in_port(self.input_repeat_location) self.add_out_port(self.output_node_location)
def __init__(self, name: str, iot_layer_config: IoTDevicesLayerConfiguration, network_config: NetworkPacketConfiguration, core_id: str): super().__init__(name) # Unpack configuration parameters ue_config_list = iot_layer_config.ues_config guard_generator = iot_layer_config.guard_time_generator # Check that UE IDs are unique self.ue_ids = [ue_id for ue_id in ue_config_list] if len(self.ue_ids) != len(set(self.ue_ids)): raise ValueError('UE IDs must be unique') # Start and add components ues = { ue_id: UserEquipmentLite(name + '_ue_' + ue_id, ue_config, network_config, core_id, guard_generator.guard_time()) for ue_id, ue_config in ue_config_list.items() } [self.add_component(ue) for ue in ues.values()] self.output_network = Port(NetworkPacket, 'output_network') self.output_service_delay_report = Port(ServiceDelayReport, 'output_service_delay_report') self.add_out_port(self.output_network) self.add_out_port(self.output_service_delay_report) self.inputs_network = dict() for ue_id in ues: self.inputs_network[ue_id] = Port(NetworkPacket, 'input_network_' + ue_id) self.add_in_port(self.inputs_network[ue_id]) self.add_coupling(self.inputs_network[ue_id], ues[ue_id].input_network) self.add_coupling(ues[ue_id].output_network, self.output_network) self.add_coupling(ues[ue_id].output_service_delay_report, self.output_service_delay_report)
def __init__(self, name: str, master_nodes: Dict[str, NodeConfiguration], slave_nodes: Dict[str, NodeConfiguration], default_link: LinkConfiguration, topology: Dict[str, Dict[str, Dict[str, None]]], channel_div_name: str = None, channel_div_config: Dict = None): for node_from, links in topology.items(): assert node_from in master_nodes for node_to in links: assert node_to in slave_nodes super().__init__(name, master_nodes, slave_nodes, default_link, topology) # the one in charge of divinding the spectrum (APs) self.channel_div = None if channel_div_name is None: channel_div_name = 'equal' if channel_div_config is None: channel_div_config = dict() self.channel_div = self.channel_div_factory.create_division(channel_div_name, **channel_div_config) self.input_enable_channels = Port(EnableChannels, 'input_enable_channels') self.output_channel_share = Port(ChannelShare, 'output_channel_share') self.add_in_port(self.input_enable_channels) self.add_out_port(self.output_channel_share)
def __init__(self, name: str, ue_id: str, service_config: ServiceConfiguration, network_config: NetworkPacketConfiguration, t_initial: float, lite_id: str = None): """ Service xDEVS module :param name: name of the xDEVS module :param ue_id: User Equipment ID :param service_config: service configuration :param network_config: network configuration :param t_initial: initial back off time before starting to operate """ self.service_id = service_config.service_id super().__init__(name + "_" + self.service_id) data_generator = ServiceDataGenerator(name + '_data_generator', ue_id, service_config, t_initial) session_manager = ServiceSessionManager(name + '_session_manager', ue_id, service_config, network_config, t_initial, lite_id) self.add_component(data_generator) self.add_component(session_manager) self.input_network = Port(NetworkPacket, 'input_network') self.output_network = Port(NetworkPacket, 'output_network') self.output_service_delay_report = Port(ServiceDelayReport, 'output_service_delay_report') self.add_in_port(self.input_network) self.add_out_port(self.output_network) self.add_out_port(self.output_service_delay_report) lite = lite_id is not None if not lite: self.input_connected_ap = Port(ConnectedAccessPoint, 'input_connected_ap') self.output_service_required = Port(ServiceRequired, 'output_service_required') self.add_in_port(self.input_connected_ap) self.add_out_port(self.output_service_required) self.external_couplings_session_manager(session_manager, lite) self.internal_couplings(data_generator, session_manager)