Example #1
0
        def allocate_fn(resources, nets, machine, constraints, placements,
                        **kwargs):
            assert place.call_count == 1

            # Check that the arguments were correct
            assert resources == {v: v.resources for v in nl.vertices}
            assert nets == nl.nets

            for c in flatten(v.constraints for v in nl.vertices):
                assert c in constraints

            # Assert there is a constraint on not using core 0
            if isinstance(constraints[0], ReserveResourceConstraint):
                assert constraints[0].resource is Cores
                assert constraints[0].reservation == slice(0, 1)
                assert constraints[0].location is None
            elif isinstance(constraints[-1], ReserveResourceConstraint):
                assert constraints[-1].resource is Cores
                assert constraints[-1].reservation == slice(0, 1)
                assert constraints[-1].location is None
            else:
                assert False, "Missing monitor processor reserving constraint."

            assert placements == {v1: (0, 0), v2a: (0, 1), v2b: (1, 0)}
            assert kwargs == allocater_kwargs

            # Return some allocations
            return {
                v1: {Cores: slice(0, 1)},
                v2a: {Cores: slice(9, 10)},
                v2b: {Cores: slice(4, 6)},
            }
Example #2
0
        def place_fn(resources, nets, machine, constraints, **kwargs):
            # Check that the arguments were correct
            assert resources == {v: v.resources for v in nl.vertices}
            assert nets == nl.nets

            for c in flatten(v.constraints for v in nl.vertices):
                assert c in constraints

            assert kwargs == placer_kwargs

            # Return some placements
            return {v1: (0, 0), v2a: (0, 1), v2b: (1, 0)}
Example #3
0
        def route_fn(resources, nets, machine_, constraints, placements,
                     allocations, **kwargs):
            assert keyspace_container.assign_fields.call_count == 1

            # Check that the arguments are correct
            assert resources == {v: v.resources for v in nl.vertices}
            assert nets == nl.nets
            assert machine_ is machine

            for c in flatten(v.constraints for v in nl.vertices):
                assert c in constraints

            assert placements == {v1: (0, 0), v2a: (0, 1), v2b: (1, 0)}
            assert allocations == {v1: {Cores: slice(0, 1)},
                                   v2a: {Cores: slice(9, 10)},
                                   v2b: {Cores: slice(4, 6)}, }
            assert kwargs == router_kwargs

            # Return some routes
            return {net: routing_tree}
def test_flatten():
    """Test flattening of nested iterables."""
    assert list(nsitertools.flatten([1, 2, [3, 4, 5, [[6]]]])) == \
        [1, 2, 3, 4, 5, 6]