def test_simulate_with_stime_limit(): def f(sim): sim.data.append('f') sim.schedule(2, g) def g(sim): sim.data.append('g') def init(sim): sim.schedule(1, f) sim.data.append('init') ret1 = simulate([], init, stime_limit=0.5) ret2 = simulate([], init, stime_limit=1) ret3 = simulate([], init, stime_limit=2) ret4 = simulate([], init, stime_limit=3) assert ret1.data == ['init'] assert ret2.data == ['init', 'f'] assert ret3.data == ['init', 'f'] assert ret4.data == ['init', 'f', 'g'] assert ret1.num_events == 0 assert ret2.num_events == 1 assert ret3.num_events == 1 assert ret4.num_events == 2 assert ret1.stime == 1 assert ret2.stime == 3 assert ret3.stime == 3 assert ret4.stime == 3
def test_params_accessible_via_getattr_and_getitem(): params = {'x': 10, 'y': 'hello'} def init(sim): assert sim.params.x == 10 assert sim.params['x'] == 10 assert sim.params.y == 'hello' simulate([], init=init, params=params)
def test_tree_traverse_with_trace_on_enter_and_on_leave(): """Validate traversing the tree twice writing trace on enter and on leave. In this test we call the simulation two times. For the first time, we use the standard traversing with adding node labels to trace on node enter. For the second time, we change enter and leave implementation to add node labels to trace during node leaving instead of entering. We check that the traversal time is the same (we still visit all nodes), but the trace is another. Besides that, we validate the results co-exist and are not shared. """ def trace_on_leave__enter(sim, node): assert not node.visited node.visited = True sim.schedule(node.delay, visit_next_child, args=[node]) def trace_on_leave__leave(sim, node): sim.data.trace.append(node.label) if node.parent and node.parent.visited: sim.schedule(0, visit_next_child, args=(node.parent, )) trace_on_enter_result = simulate(TreeData, init=start_from_root, handlers={ 'enter': enter_node, 'leave': leave_node, }) trace_on_leave_result = simulate(TreeData, init=start_from_root, handlers={ 'enter': trace_on_leave__enter, 'leave': trace_on_leave__leave, }) trace_stime_limit_result = simulate(TreeData, init=start_from_root, handlers={ 'enter': enter_node, 'leave': leave_node, }, stime_limit=7) np.testing.assert_allclose(trace_on_enter_result.stime, 15.0, atol=0.1) np.testing.assert_allclose(trace_on_leave_result.stime, 15.0, atol=0.1) np.testing.assert_allclose(trace_stime_limit_result.stime, 10.0, atol=0.1) assert trace_on_enter_result.data.trace == ['A', 'B', 'C', 'D', 'E'] assert trace_on_leave_result.data.trace == ['D', 'C', 'E', 'B', 'A'] assert trace_stime_limit_result.data.trace == ['A', 'B', 'C', 'D']
def test_simulate_accept_classes_without_create(): class ModelData: default_value = 'default value' def __init__(self): self.value = ModelData.default_value ret_for_default_value = simulate(ModelData) ModelData.default_value = 'new value' ret_for_updated_value = simulate(ModelData) assert ret_for_default_value.data.value == 'default value' assert ret_for_updated_value.data.value == 'new value'
def simulate_network(topology, failure_interval, repair_interval, num_offline_till_repair=2, **kwargs): stime_limit = kwargs.get('stime_limit', defaults['stime_limit']) num_runs = kwargs.get('num_runs', defaults['num_runs']) log_level = kwargs.get('log_level', Logger.Level.ERROR) routing_mode = { 'static': Network.STATIC, 'dynamic': Network.DYNAMIC }[kwargs.get('routing_mode', 'static')] cons_repair_interval = kwargs.get('cons_repair_interval', repair_interval) results = [] for i_run in range(num_runs): results.append( simulate(ModelData, stime_limit=stime_limit, params={ 'topology': topology, 'routing_mode': routing_mode, 'failure_interval': failure_interval, 'repair_interval': repair_interval, 'num_offline_till_repair': num_offline_till_repair, 'log_level': log_level, 'cons_repair_interval': cons_repair_interval, 'record_samples': kwargs.get('record_samples', False), 'sample_interval': kwargs.get('sample_interval', 1), })) return _SimRet(results)
def test_schedule_accept_none_handler_by_changing_only_time(): def init(sim): sim.schedule(5) ret = simulate([], init=init) assert ret.stime == 5
def test_random_source_provides_statistics(): """Validate that `RandomSource` provides statistics. """ intervals = (10, 12, 15, 17) data_size = (123, 453, 245, 321) class TestModel(Model): def __init__(self, sim): super().__init__(sim) self.source = RandomSource( sim, source_id=34, dest_addr=13, data_size=Mock(side_effect=data_size), interval=Mock(side_effect=(intervals + (1000, ))), ) self.network = DummyModel(sim, 'Network') self.source.connections['network'] = self.network ret = simulate(TestModel, stime_limit=sum(intervals)) assert ret.data.source.arrival_intervals.as_tuple() == intervals assert ret.data.source.data_size_stat.as_tuple() == data_size # Also check that we can not replace statistics: with pytest.raises(AttributeError): from pydesim import Intervals ret.data.source.arrival_intervals = Intervals() with pytest.raises(AttributeError): from pydesim import Statistic ret.data.source.data_size_stat = Statistic() # Check that source records the number of packets being sent: assert ret.data.source.num_packets_sent == 4
def test_dcf_line_network_with_single_source(num_stations): sr = simulate( WirelessHalfDuplexLineNetwork, stime_limit=SIM_TIME_LIMIT, params=dict( num_stations=num_stations, active_sources=[0], payload_size=PAYLOAD_SIZE, source_interval=SOURCE_INTERVAL, mac_header_size=MAC_HEADER, phy_header_size=PHY_HEADER, ack_size=ACK_SIZE, preamble=PREAMBLE, bitrate=BITRATE, difs=DIFS, sifs=SIFS, slot=SLOT, cwmin=CWMIN, cwmax=CWMAX, distance=DISTANCE, connection_radius=CONNECTION_RADIUS, speed_of_light=SPEED_OF_LIGHT, ), loglevel=Logger.Level.INFO ) client = sr.data.stations[0] server = sr.data.stations[-1] source_id = client.source.source_id expected_number_of_packets = floor(SIM_TIME_LIMIT / SOURCE_INTERVAL.mean()) assert client.source.num_packets_sent == expected_number_of_packets assert (expected_number_of_packets - 1 <= server.sink.num_packets_received <= expected_number_of_packets) mean_payload = PAYLOAD_SIZE.mean() expected_service_time = ( DIFS + CWMIN/2 * SLOT + PREAMBLE + (mean_payload + MAC_HEADER + PHY_HEADER) / BITRATE + SIFS + PREAMBLE + (PHY_HEADER + ACK_SIZE) / BITRATE + 2 * DISTANCE / SPEED_OF_LIGHT ) expected_end_to_end_delay = expected_service_time * (num_stations - 1) assert_allclose( server.sink.source_delays[source_id].mean(), expected_end_to_end_delay, rtol=0.2 ) client_if = client.get_interface_to(server) assert client_if.queue.size_trace.timeavg() == 0 assert_allclose( client_if.transmitter.busy_trace.timeavg(), expected_service_time / SOURCE_INTERVAL.mean(), rtol=0.2 )
def test_saturated_network_with_three_stations(): sr = simulate( CollisionDomainSaturatedNetwork, stime_limit=SIM_TIME_LIMIT, params=dict( num_stations=3, payload_size=PAYLOAD_SIZE, mac_header_size=MAC_HEADER, phy_header_size=PHY_HEADER, ack_size=ACK_SIZE, preamble=PREAMBLE, bitrate=BITRATE, difs=DIFS, sifs=SIFS, slot=SLOT, cwmin=CWMIN, cwmax=CWMIN, # the same here, no increase to calculate p_collision connection_radius=CONNECTION_RADIUS, speed_of_light=SPEED_OF_LIGHT, queue_capacity=None, ), loglevel=Logger.Level.WARNING ) # Since all stations send data to station 0, we assign these stations # to more valuable variables: access_point = sr.data.stations[0] access_point_iface = access_point.interfaces[0] # We validate the collisions probabilities: p_collision = access_point_iface.receiver.num_collisions / ( access_point_iface.receiver.num_collisions + access_point_iface.receiver.num_received ) assert_allclose(p_collision, 1 / CWMIN, rtol=0.1)
def test_large_collision_domain_network__smoke(): """In this test we validate that all stations are really in a single domain and run the model for some time. We actually do not test any meaningful properties, except connections and that only server receives data. """ num_stations = randint(5, 15) source_interval = Exponential(uniform(1.0, 10.0)) payload_size = Exponential(randint(10, 100)) sr = simulate( CollisionDomainNetwork, stime_limit=500, params=dict( num_stations=num_stations, payload_size=payload_size, source_interval=source_interval, mac_header_size=MAC_HEADER, phy_header_size=PHY_HEADER, ack_size=ACK_SIZE, preamble=PREAMBLE, bitrate=BITRATE, difs=DIFS, sifs=SIFS, slot=SLOT, cwmin=CWMIN, cwmax=CWMAX, connection_radius=CONNECTION_RADIUS, speed_of_light=SPEED_OF_LIGHT, queue_capacity=None, ), loglevel=Logger.Level.WARNING ) access_point = sr.data.stations[0] clients = sr.data.stations[1:] conn_man = sr.data.connection_manager # Test that connections are established between all stations: for i in range(num_stations): radio = sr.data.get_iface(i).radio peers = set(conn_man.get_peers(radio)) assert len(peers) == num_stations - 1 and radio not in peers # Test that the number of packets received by any client sink is 0: for client in clients: assert client.sink.num_packets_received == 0 # Test that the number of packets generated by the sources - (queue sizes # + number of packets in transceivers) at the end of simulation is # almost equal to the number of received packets by the access point sink: num_packets_sent = [ (cli.source.num_packets_sent - cli.interfaces[0].queue.size() - (1 if cli.interfaces[0].transmitter.state else 0)) for cli in clients ] num_packets_received = access_point.sink.num_packets_received assert_allclose(sum(num_packets_sent), num_packets_received, rtol=0.05)
def test_schedule_negative_delays_not_allowed(): def invalid_init(sim): sim.schedule(-1) def invalid_handler(sim): sim.schedule(-0.1) def valid_init(sim): sim.schedule(10, invalid_handler) with pytest.raises(ValueError) as excinfo1: simulate([], init=invalid_init) with pytest.raises(ValueError) as excinfo2: simulate([], init=valid_init) assert "negative delay" in str(excinfo1.value).lower() assert "negative delay" in str(excinfo2.value).lower()
def test_sim_provide_cancel_operation(): def init(sim): eid = sim.schedule(1) sim.cancel(eid) ret = simulate([], init) assert ret.stime == 0 assert ret.num_events == 0
def test_simulate_accepts_classes_with_create_method(): class ModelData: default_value = 'correct value' def __init__(self, value='incorrect value'): self.value = value @classmethod def create(cls): return ModelData(cls.default_value) ret_for_default_value = simulate(ModelData) ModelData.default_value = 'some new value' ret_for_updated_value = simulate(ModelData) assert ret_for_default_value.data.value == 'correct value' assert ret_for_updated_value.data.value == 'some new value'
def test_mm1_multihop_tandem_model_with_cross_traffic(arrival, service, stime_limit, num_stations): ret = simulate(QueueingTandemNetwork, stime_limit=stime_limit, params={ 'arrivals': [arrival for _ in range(num_stations)], 'services': [service for _ in range(num_stations)], 'queue_capacity': None, 'num_stations': num_stations, }) n = num_stations mean_service = service.mean() mean_arrival = arrival.mean() rho = mean_service / mean_arrival expected_node_delays = [] for i in range(num_stations): server = ret.data.servers[i] queue = ret.data.queues[i] est_busy_rate = server.busy_trace.timeavg() est_system_size = ret.data.system_size_trace[i].timeavg() est_arrival_mean = queue.arrival_intervals.statistic().mean() est_service_mean = server.service_intervals.mean() est_departure_mean = server.departure_intervals.statistic().mean() est_system_wait = ret.data.system_wait_intervals[i].mean() est_queue_wait = queue.wait_intervals.mean() expected_busy_rate = rho * (i + 1) expected_service_mean = mean_service expected_system_size = expected_busy_rate / (1 - expected_busy_rate) expected_arrival_mean = mean_arrival / (i + 1) expected_departure_mean = expected_arrival_mean expected_node_delays.append(expected_system_size * expected_arrival_mean) assert_allclose(est_busy_rate, expected_busy_rate, rtol=0.25) assert_allclose(est_service_mean, expected_service_mean, rtol=0.25) assert_allclose(est_system_size, expected_system_size, rtol=0.25) assert_allclose(est_arrival_mean, expected_arrival_mean, rtol=0.25) assert_allclose(est_departure_mean, expected_departure_mean, rtol=0.25) assert_allclose(est_system_wait, expected_node_delays[-1], rtol=0.25) assert_allclose(est_queue_wait, expected_node_delays[-1] - expected_service_mean, rtol=0.25) est_delays = [ret.data.sources[i].delays.mean() for i in range(n)] expected_delays = [0.0] * n for i in range(n - 1, -1, -1): expected_delays[i] = expected_node_delays[i] + (expected_delays[i + 1] if i < n - 1 else 0) assert_allclose(est_delays, expected_delays, rtol=0.35)
def test_tree_traverse_in_parallel(): """Validate events scheduled in parallel work properly, and using raw data. In this test we schedule visiting all children once we enter the state, after the same delay. We do not come back to parent, so 'leave' event is not specified. This is like traversing the tree using unlimited number of threads by starting new thread for each child just after processing the parent. Since then, the delay is just the maximum delay of a branch. Besides that, we define data as a `namedtuple`, not `TreeData`, and check that is is used properly and put into the result. To be sure the events are queued in the correct order, we add several nodes (F, G, H, I, J) to the tree: (A [d=1], (B [d=2], (C [d=3], (D [d=4], (J [d=1]))), (E [d=5], (H [d=1], (I [d=1]))), (F [d=2], (G [d=2])) ) ) The visiting order is expected like this: A -> B -> C -> E -> F -> G -> D -> H -> I -> J """ tree = create_tree() node_f = TreeNode(2.0, 'F') node_g = TreeNode(2.0, 'G') node_h = TreeNode(1.0, 'H') node_i = TreeNode(1.0, 'I') node_j = TreeNode(1.0, 'J') tree.get('B').add_child(node_f) tree.get('D').add_child(node_j) tree.get('E').add_child(node_h) node_f.add_child(node_g) node_h.add_child(node_i) data_class = namedtuple('ModelData', ['tree', 'trace']) data = data_class(tree=tree, trace=[]) def visit(sim, node): assert not node.visited node.visited = True sim.data.trace.append(node.label) if node.children: for child in node.children: sim.schedule(node.delay, visit, args=[child]) else: sim.schedule(node.delay) ret = simulate(data, init=start_from_root, handlers={'enter': visit}) np.testing.assert_allclose(ret.stime, 11.0, atol=0.1, rtol=0.01) assert ret.data.trace == ['A', 'B', 'C', 'E', 'F', 'G', 'D', 'H', 'I', 'J'] assert ret.data == data # also check that data is the same
def test_schedule_multiple_events(): def handler(sim): sim.data.append(sim.stime) def init(sim): sim.schedule(1, handler) sim.schedule(2, handler) ret = simulate([], init=init) assert ret.data == [1, 2]
def test_simulate_calls_constructor_without_parameters_but_with_sim(): with patch('pydesim.simulator.Simulator') as SimulatorMock: class SomeModel(Model): def __init__(self, sim): assert isinstance(sim, SimulatorMock) super().__init__(self, sim) assert sim.params.x == 10 assert sim.params.y == 'hello' result = simulate(SomeModel, params={'x': 10, 'y': 'hello'})
def test_stime_is_readonly(): def valid_handler(sim): sim.data.append('OK') def valid_init(sim): sim.schedule(1, sim.handlers.handler) with pytest.raises(AttributeError) as excinfo1: def invalid_init(sim): sim.stime = 10 simulate([], init=invalid_init) with pytest.raises(AttributeError) as excinfo2: def invalid_handler(sim): sim.stime += 1 simulate([], init=valid_init, handlers={'handler': invalid_handler}) with pytest.raises(AttributeError) as excinfo3: def invalid_fin(sim): sim.stime -= 1 simulate([], init=valid_init, fin=invalid_fin, handlers={'handler': valid_handler}) assert 'set attribute' in str(excinfo1.value) assert 'set attribute' in str(excinfo2.value) assert 'set attribute' in str(excinfo3.value)
def tandem_queue_network_with_fixed_service(arrivals, service, queue_capacity, stime_limit): num_stations = len(arrivals) sr = simulate(QueueingTandemNetworkWithFixedService, stime_limit=stime_limit, params={ 'arrivals': arrivals, 'service': service, 'queue_capacity': queue_capacity, 'num_stations': num_stations, }) simret_class = namedtuple('SimRet', ['nodes']) node_class = namedtuple('Node', [ 'delay', 'queue_size', 'system_size', 'busy', 'arrivals', 'departures', 'service', 'num_served', 'num_arrived', 'num_dropped', 'drop_ratio', 'queue_wait', 'system_wait', ]) active_nodes = {i for i in range(num_stations) if arrivals[i] is not None} nodes = [ node_class( delay=(sr.data.sources[i].delays if i in active_nodes else None), queue_size=sr.data.queues[i].size_trace, system_size=sr.data.system_size_trace[i], busy=sr.data.servers[i].busy_trace, arrivals=sr.data.queues[i].arrival_intervals.statistic(), departures=sr.data.servers[i].departure_intervals.statistic(), service=sr.data.servers[i].service_intervals, num_served=sr.data.servers[i].num_served, num_arrived=sr.data.queues[i].num_arrived, num_dropped=sr.data.queues[i].num_dropped, drop_ratio=sr.data.queues[i].drop_ratio, queue_wait=sr.data.queues[i].wait_intervals, system_wait=sr.data.system_wait_intervals[i], ) for i in range(num_stations) ] return simret_class(nodes=nodes)
def test_controlled_source_provides_statistics(): """Validate that `ControlledSource` provides statistics. """ intervals = (10, 12, 15, 17) data_size = (123, 453, 245, 321) class SourceController(Model): def __init__(self, sim, src): super().__init__(sim) self.iterator = iter(intervals) self.src = src self.sim.schedule(next(self.iterator), self.handle_timeout) def handle_timeout(self): self.src.get_next() try: interval = next(self.iterator) except StopIteration: pass else: self.sim.schedule(interval, self.handle_timeout) class TestModel(Model): def __init__(self, sim): super().__init__(sim) self.source = ControlledSource( sim, source_id=34, dest_addr=13, data_size=Mock(side_effect=data_size), ) self.network = DummyModel(sim, 'Network') self.source.connections['network'] = self.network self.controller = SourceController(sim, self.source) ret = simulate(TestModel, stime_limit=sum(intervals)) assert ret.data.source.data_size_stat.as_tuple() == data_size assert ret.data.source.arrival_intervals.as_tuple() == intervals # Also check that we can not replace statistics: with pytest.raises(AttributeError): from pydesim import Intervals ret.data.source.arrival_intervals = Intervals() with pytest.raises(AttributeError): from pydesim import Statistic ret.data.source.data_size_stat = Statistic() # Check that source records the number of packets being sent: assert ret.data.source.num_packets_sent == 4
def test_scheduled_methods_are_called_in_chain(): def write_some_data(sim, value='first'): sim.data.append(value) if value == 'first': sim.schedule(3, write_some_data, args=('second', )) elif value == 'second': sim.schedule(10, write_some_data, kwargs={'value': 'third'}) def init(sim): sim.schedule(1, write_some_data) ret = simulate([], init=init) assert ret.stime == 14 assert ret.data == ['first', 'second', 'third']
def test_simulate_executes_init_and_fin(): """In this test we validate that `simulate()` calls init and fin methods. """ data = [] def init(sim): sim.data.append(1) def fin(sim): sim.data.append('A') ret = simulate(data, init=init, fin=fin, handlers={}, stime_limit=1) assert ret.stime == 0 assert ret.data == [1, 'A']
def test_wired_line_network_with_single_source(num_stations): sr = simulate(WiredLineNetwork, stime_limit=SIM_TIME_LIMIT, params=dict( num_stations=num_stations, payload_size=PAYLOAD_SIZE, source_interval=SOURCE_INTERVAL, header_size=HEADER_SIZE, bitrate=BITRATE, distance=DISTANCE, speed_of_light=SPEED_OF_LIGHT, active_sources=[0], preamble=PREAMBLE, ifs=IFS, ), loglevel=Logger.Level.ERROR) client = sr.data.stations[0] server = sr.data.stations[-1] source_id = client.source.source_id expected_interval_avg = SOURCE_INTERVAL.mean() expected_number_of_packets = floor(SIM_TIME_LIMIT / expected_interval_avg) assert client.source.num_packets_sent == expected_number_of_packets assert (expected_number_of_packets - 1 <= server.sink.num_packets_received <= expected_number_of_packets) expected_transmission_delay = ( (PAYLOAD_SIZE.mean() + HEADER_SIZE) / BITRATE + PREAMBLE + IFS) expected_delay = ( (DISTANCE / SPEED_OF_LIGHT + expected_transmission_delay) * (num_stations - 1)) assert_allclose(server.sink.source_delays[source_id].mean(), expected_delay, rtol=0.1) client_if = client.get_interface_to(server) assert client_if.queue.size_trace.timeavg() == 0 expected_busy_ratio = expected_transmission_delay / expected_interval_avg assert_allclose(client_if.transceiver.tx_busy_trace.timeavg(), expected_busy_ratio, rtol=0.1)
def test_handlers_can_be_passed_and_accessed_via_sim_handlers_field(): def f1(sim): sim.data.append(1) sim.schedule(0, sim.handlers.get('second')) def f2(sim): sim.data.append(2) sim.schedule(0, sim.handlers.third) def f3(sim): sim.data.append(3) def init(sim): sim.schedule(0, sim.handlers['first']) ret = simulate([], init=init, handlers=dict(first=f1, second=f2, third=f3)) assert ret.data == [1, 2, 3]
def test_schedule_orders_events_by_time(): def f(sim): sim.data.append(f'{int(sim.stime)}F') sim.schedule(1.0, g) def g(sim): sim.data.append(f'{int(sim.stime)}G') def h(sim): sim.data.append(f'{int(sim.stime)}H') def init(sim): sim.schedule(1.0, f) sim.schedule(4.0, f) sim.schedule(3.0, h) ret = simulate([], init) assert ret.data == ['1F', '2G', '3H', '4F', '5G']
def test_objective_mm1_model(mean_arrival, mean_service): ret = simulate(QueueingSystem, stime_limit=4000, params={ 'arrival_mean': mean_arrival, 'service_mean': mean_service, 'capacity': -1, }) busy_rate = ret.data.server.busy_trace.timeavg() system_size = ret.data.system_size_trace.timeavg() est_arrival_mean = ret.data.source.intervals.statistic().mean() est_departure_mean = ret.data.sink.departures.statistic().mean() est_service_mean = ret.data.server.delays.mean() rho = mean_service / mean_arrival assert np.allclose(est_service_mean, mean_service, rtol=0.2) assert np.allclose(busy_rate, rho, rtol=0.2) assert np.allclose(system_size, rho / (1 - rho), atol=0.05, rtol=0.2) assert np.allclose(est_arrival_mean, mean_arrival, rtol=0.2) assert np.allclose(est_departure_mean, mean_arrival, rtol=0.2)
def test_tree_traverse_from_b_and_reverse_trace(): """In this test we check that init and finalize methods are really called. We start the test at node B instead of A (root) and make sure that both trace and traversal time change. Moreover, we reverse the trace in the end by passing a finalization function which calls `list.reverse()` """ def start_from_b(sim): root = sim.data.tree.find('B') sim.schedule(0, sim.handlers['enter'], args=[root]) def reverse_trace(sim): sim.data.trace.reverse() ret = simulate(TreeData, init=start_from_b, fin=reverse_trace, handlers={ 'enter': enter_node, 'leave': leave_node, }) np.testing.assert_allclose(ret.stime, 14.0, atol=0.1, rtol=0.01) assert ret.data.trace == ['E', 'D', 'C', 'B']
def test_cancel_tree_printing_before_deadline(): """Validate cancel operation works properly. In this test we schedule printing all the nodes ('A'..'E') at one moment (at t=5). However, we also launch tree traversal (from t=0), and we cancel the scheduled print when visiting the tree. It looks like we will cancel printing for nodes A, B and ะก. When printing, we also cancel entering the node, so simulation will stop at t=5, after print all nodes to which we didn't come. """ def enter_silent(sim, node): sim.cancel(sim.data.visit_evids[node.label]) del sim.data.visit_evids[node.label] for child in node.children: eid = sim.schedule(node.delay, enter_silent, args=(child,)) sim.data.enter_evids[child.label] = eid def visit_node(sim, node): sim.data.trace.append(node.label) sim.cancel(sim.data.enter_evids[node.label]) del sim.data.enter_evids[node.label] def init(sim): def schedule_visit(node): eid = sim.schedule(5, visit_node, args=(node,)) sim.data.visit_evids[node.label] = eid sim.data.tree.apply(schedule_visit) sim.schedule(0, enter_silent, args=(sim.data.tree,)) data_class = namedtuple( 'ModelData', ['tree', 'trace', 'visit_evids', 'enter_evids'] ) data = data_class(create_tree(), trace=[], visit_evids={}, enter_evids={}) ret = simulate(data, init) assert ret.data.trace == ['D'] assert ret.stime == 5
def test_mm1_single_hop_tandem_model(arrival, service, stime_limit): ret = simulate(QueueingTandemNetwork, stime_limit=stime_limit, params={ 'arrivals': [arrival], 'services': [service], 'queue_capacity': None, 'num_stations': 1, }) busy_rate = ret.data.servers[0].busy_trace.timeavg() system_size = ret.data.system_size_trace[0].timeavg() est_arrival_mean = ret.data.sources[0].intervals.statistic().mean() est_service_mean = ret.data.servers[0].service_intervals.mean() est_delay = ret.data.sources[0].delays.mean() est_departure_mean = ret.data.sink.arrival_intervals.statistic().mean() est_sys_wait = ret.data.system_wait_intervals[0].mean() est_queue_wait = ret.data.queues[0].wait_intervals.mean() mean_service = service.mean() mean_arrival = arrival.mean() rho = mean_service / mean_arrival expected_delay = mean_arrival * rho / (1 - rho) assert_allclose(est_service_mean, mean_service, rtol=0.25) assert_allclose(busy_rate, rho, rtol=0.25) assert_allclose(system_size, rho / (1 - rho), atol=0.05, rtol=0.25) assert_allclose(est_arrival_mean, mean_arrival, rtol=0.25) assert_allclose(est_departure_mean, mean_arrival, rtol=0.25) assert_allclose(est_delay, expected_delay, rtol=0.25) assert_allclose(est_sys_wait, expected_delay, rtol=0.25) assert_allclose(est_queue_wait, expected_delay - mean_service, 0.25) assert ret.data.queues[0].drop_ratio == 0 assert ret.data.queues[0].num_dropped == 0 assert ret.data.queues[0].num_arrived > 0 assert ret.data.servers[0].num_served > 0
def test_mm1_model(arrival, service, stime_limit): ret = simulate(QueueingSystem, stime_limit=stime_limit, params={ 'arrival': arrival, 'service': service, 'queue_capacity': None, }) busy_rate = ret.data.server.busy_trace.timeavg() system_size = ret.data.system_size_trace.timeavg() est_arrival_mean = ret.data.source.intervals.statistic().mean() est_departure_mean = ret.data.sink.arrival_intervals.statistic().mean() est_service_mean = ret.data.server.service_intervals.mean() est_delay = ret.data.source.delays.mean() est_sys_wait = ret.data.system_wait_intervals.mean() est_queue_wait = ret.data.queue.wait_intervals.mean() mean_service = service.mean() mean_arrival = arrival.mean() rho = mean_service / mean_arrival expected_delay = mean_arrival * rho / (1 - rho) assert_allclose(est_service_mean, mean_service, rtol=0.25) assert_allclose(busy_rate, rho, rtol=0.25) assert_allclose(system_size, rho / (1 - rho), rtol=0.25) assert_allclose(est_arrival_mean, mean_arrival, rtol=0.25) assert_allclose(est_departure_mean, mean_arrival, rtol=0.25) assert_allclose(est_delay, expected_delay, rtol=0.25) assert_allclose(est_sys_wait, expected_delay, rtol=0.25) assert_allclose(est_queue_wait, expected_delay - mean_service, 0.25) assert ret.data.queue.drop_ratio == 0 assert ret.data.queue.num_dropped == 0 assert ret.data.queue.num_arrived > 0 assert ret.data.server.num_served > 0